package com.wicket.okrframework.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrframework.base.service.MChangeColumnService;
import com.wicket.okrframework.base.service.dto.req.BatchQueryBaseChangeColListByCodesReq;
import com.wicket.okrframework.base.service.dto.req.DeptDto;
import com.wicket.okrframework.base.service.dto.req.QueryBaseChangeColListReq;
import com.wicket.okrframework.biz.service.dto.common.*;
import com.wicket.okrframework.biz.service.dto.common.BaseChangeColumnDto;
import com.wicket.okrframework.biz.service.dto.req.*;
import com.wicket.okrframework.biz.service.dto.res.*;
import com.wicket.okrframework.biz.service.nb.NbChangeColumn;
import com.wicket.okrframework.common.annotations.BanAuto;
import com.wicket.okrframework.common.exception.BizException;
import com.wicket.okrframework.common.util.CommonFunctionHelper;
import com.wicket.okrframework.common.util.RedisUtil;
import com.wicket.okrframework.dal.po.mbg.ChangeColumn;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import com.wicket.okrframework.base.service.dto.req.QueryBaseChangeColDetailReq;
import com.wicket.okrframework.common.exception.Assert;
import com.wicket.okrframework.base.service.MInductionRecordService;
import com.wicket.okrframework.base.service.MPositionService;
import com.wicket.okrframework.base.service.dto.req.ImplementChangeColLoopStartReq;
import java.util.Collections;
import cn.hutool.core.util.ObjectUtil;
import com.wicket.okrframework.dal.po.mbg.InductionRecord;
import com.wicket.okrframework.biz.service.InductionRecordService;
import com.wicket.okrframework.base.service.MBatchService;
import com.wicket.okrframework.dal.po.mbg.Batch;
import com.wicket.okrframework.base.service.dto.req.ImplementSpinLockCheckBaseBatchReq;
import java.util.concurrent.Callable;
import com.wicket.okrframework.base.service.MDeptService;
import com.wicket.okrframework.dal.po.mbg.Dept;
import cn.hutool.core.collection.CollectionUtil;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class ChangeColumnServiceImpl
        implements com.wicket.okrframework.biz.service.ChangeColumnService {

    @Resource
    private RedisUtil redisUtil;
    // @Resource
    // private MSpecMethordTableService mSpecMethordTableService;
    @Resource
    private MChangeColumnService mChangeColumnService;
    @Resource
    private DataSource dataSource;
    @Resource
    private NbChangeColumn nbChangeColumn;
@Resource
  private MInductionRecordService mInductionRecordService;
@Resource
  private MPositionService mPositionService;
@Resource
  private InductionRecordService inductionRecordService;
@Resource
  private MBatchService mBatchService;
@Resource
  private MDeptService mDeptService;
//@Resource
 //private MCustomFields2Service mCustomFields2Service;
//@Resource
 //private undefinedService undefinedService;

    /**
   * D1-1撤销修订底层框架服务变更字段[918]
   * gen by moon at 10/2/2022, 7:50:23 AM
   */
  @Trace(operationName = "D1-1撤销修订底层框架服务变更字段")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UndoReviseBaseChangeColRespDto undoReviseBaseChangeCol(UndoReviseBaseChangeColReqDto reqDto){
    
      
      //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
     List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:47652_1
queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:47651_1
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:151900_1
if(reqDto!=null){
      queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:47649_1
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:47650_1
    }
  
    /*1-1-02查询修订的变更记录[8]   */
    Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(),"D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getEntityId(),"D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getIsInproperties(),"D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-1撤销修订底层框架服务变更字段-1-1-02查询修订的变更记录-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
      Assert.isTrue(listChangeColumn== null||  listChangeColumn ==null|| listChangeColumn.size()==0 ,"返回值不能为空",false);
      
      
    
//步骤1: 1-1-02批量删除底层框架服务变更字段 - batchDeleteBaseChangeColumn	
     boolean bOOLEAN ;
    if(listChangeColumn !=null&& listChangeColumn.size()>0 ){
          List<String> listString=new ArrayList<>();
  listString = listChangeColumn.stream().map(item->item.getChangeColumnId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:47655_1
  
    /*1-1-02批量删除修订的变更记录[7]   */
    
      bOOLEAN = mChangeColumnService.batchDeleteBaseChangeColumn(listString);
      
      
      
           }
    
UndoReviseBaseChangeColRespDto retData = new UndoReviseBaseChangeColRespDto();
  
  

  
  
return retData;
  }

    /**
   * D1-1修订底层框架服务变更字段[272]
   * gen by moon at 9/1/2022, 9:47:33 PM
   */
  @Trace(operationName = "D1-1修订底层框架服务变更字段")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReviseBaseChangeColRespDto reviseBaseChangeCol(ReviseBaseChangeColReqDto reqDto){
    
      
      //virtualUsage 1-1-02查底层当前有效变更字段列表  9397
      List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:152922_1_9397
queryBaseChangeColListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:152920_1_9397
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:152917_1_9397
if(reqDto!=null){
      queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:152914_1_9397
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//sourceId:152915_1_9397
    }
  
    /*1-1-02查底层当前有效变更字段列表[8]   */
    Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(),"D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getEntityId(),"D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getIsInproperties(),"D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-1修订底层框架服务变更字段-1-1-02查底层当前有效变更字段列表-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
      
      
      
if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
        //if(D1-1修订底层框架服务变更字段.主体生命周期 等于 正在编辑)  9421
        
boolean bOOLEAN ;
    if(listChangeColumn !=null&& listChangeColumn.size()>0 ){
          List<ChangeColumn> listChangeColumn_2=new ArrayList<>();
  for (ChangeColumn item : listChangeColumn) {
                ChangeColumn oneItem = new ChangeColumn();
                oneItem.setChangeColumnId(item.getChangeColumnId());//sourceId:69786_2_9422
oneItem.setArchivngType("TOBE_ARCHIVING");//sourceId:69789_2_9422
oneItem.setArchiveInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:69787_2_9422
oneItem.setArchiveTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:69788_2_9422
               
                listChangeColumn_2.add(oneItem);
            }//sourceId:153439_1_9422
  
    /*1-1-02批量改底层变更字段状态为想存档[1630]   */
    
      bOOLEAN = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_2);
      
      
      
           }
      }
else if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))){
       //elseif(D1-1修订底层框架服务变更字段.主体生命周期 等于 当前有效)  9423
      
//ModelCode: reviseNotBatchContent
        BatchWriteBackBaseMainTableChangeColRespDto reviseNotBatchContentRes = null;
    BatchWriteBackBaseMainTableChangeColReqDto reviseNotBatchContentReq=new BatchWriteBackBaseMainTableChangeColReqDto();
  if(reqDto!=null){
      reviseNotBatchContentReq.setBaseMainTableChangeColList(reqDto.getChangeColumnList());//sourceId:286377_1_15305
    }
  
    /*M1批量回写底层框架主表变更字段（特殊方法）[3746]  入参：业务对象编码（表名）objectCode、对象属性编码（主键字段名）propertyCode、主键ID  uniqueId    对象属性+变更内容的数据集，更新任意一张表的数据 */
    
      reviseNotBatchContentRes = nbChangeColumn.batchWriteBackBaseMainTableChangeCol(reviseNotBatchContentReq);
      
      
      
boolean bOOLEAN_1 ;
    if(listChangeColumn !=null&& listChangeColumn.size()>0 ){
          List<ChangeColumn> listChangeColumn_3=new ArrayList<>();
  for (ChangeColumn item : listChangeColumn) {
                ChangeColumn oneItem = new ChangeColumn();
                oneItem.setChangeColumnId(item.getChangeColumnId());//sourceId:69790_2_9424
oneItem.setIsEditing("FALSE");//sourceId:69797_2_9424
oneItem.setIsArchive("TRUE");//sourceId:69798_2_9424
oneItem.setArchivngType("ARCHIVED");//sourceId:69794_2_9424
oneItem.setSubjectLifeCycle("ARCHIVING");//sourceId:69791_2_9424
oneItem.setArchiveInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:69792_2_9424
oneItem.setArchiveTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:69793_2_9424
               
                listChangeColumn_3.add(oneItem);
            }//sourceId:153440_1_9424
  
    /*1-1-02批量改底层变更字段状态为历史存档[1630]   */
    
      bOOLEAN_1 = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_3);
      
      
      
           }
    }
//virtualUsage 1-1-02查内容ID本次已更新字段列表（正在编辑）  9398
      List<ChangeColumn> listChangeColumn_4 =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq_1=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq_1.setSubjectUpdateStatus("REVISION");//sourceId:151656_1_9398
queryBaseChangeColListReq_1.setIsInproperties("TRUE");//sourceId:23597_1_9398
queryBaseChangeColListReq_1.setSubjectLifeCycle("EDITING");//sourceId:17175_1_9398
queryBaseChangeColListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23614_1_9398
if(reqDto!=null){
      queryBaseChangeColListReq_1.setBatchId(reqDto.getBatchId());//sourceId:181698_1_9398
queryBaseChangeColListReq_1.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:17172_1_9398
queryBaseChangeColListReq_1.setEntityId(reqDto.getEntityId());//sourceId:17173_1_9398
queryBaseChangeColListReq_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//sourceId:151654_1_9398
queryBaseChangeColListReq_1.setSubjectChangeType(reqDto.getSubjectChangeType());//sourceId:151655_1_9398
queryBaseChangeColListReq_1.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:151652_1_9398
queryBaseChangeColListReq_1.setObjectId(reqDto.getObjectId());//sourceId:151653_1_9398
    }
  
    /*1-1-02查内容ID本次已更新字段列表（正在编辑）[8]   */
    Assert.isNull(queryBaseChangeColListReq_1.getTableTypeCode(),"D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq_1.getEntityId(),"D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq_1.getSubjectTypeCode(),"D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq_1.getSubjectChangeType(),"D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体变更日志类型不能为空",false);
Assert.isNull(queryBaseChangeColListReq_1.getSubjectUpdateStatus(),"D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体批次下更新状态不能为空",false);
Assert.isNull(queryBaseChangeColListReq_1.getIsInproperties(),"D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq_1.getSubjectLifeCycle(),"D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq_1.getSpaceId(),"D1-1修订底层框架服务变更字段-1-1-02查内容ID本次已更新字段列表（正在编辑）-创建于空间ID不能为空",false);
      listChangeColumn_4 = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq_1);
      
      
      
//virtualUsage 从更新字段中，分类出新增、修改字段（空方法）  9399
      //ModelCode: dataAuClassification
        FilterAddUpdateColumnRespDto dataAuClassificationRes = null;
    FilterAddUpdateColumnReqDto dataAuClassificationReq=new FilterAddUpdateColumnReqDto();
  dataAuClassificationReq.setBaseChangeColumnList(listChangeColumn_4.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.biz.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//sourceId:151662_1_9399
if(reqDto!=null){
      dataAuClassificationReq.setChangeColumnList(reqDto.getChangeColumnList());//sourceId:47370_1_9399
    }
  
    /*从更新字段中，分类出新增、修改字段（空方法）[908]  入参两个数据集，出参两个数据集，分别对应：新增数据集、删除数据集 */
    
      dataAuClassificationRes = nbChangeColumn.filterAddUpdateColumn(dataAuClassificationReq);
      
      
      
//virtualUsage 1-1-02批量新增底层变更字段  9400
      boolean bOOLEAN_2 ;
    List<ChangeColumn> listChangeColumn_6=new ArrayList<>();
  if(dataAuClassificationRes!=null){
      for (NewColumnDto item : dataAuClassificationRes.getNewColumnList()) {
                ChangeColumn oneItem = new ChangeColumn();
                oneItem.setSubjectUpdateStatus("REVISION");//sourceId:69337_2_9400
oneItem.setIsInproperties("TRUE");//sourceId:69340_2_9400
if(dataAuClassificationRes!=null){
      oneItem.setObjectPropertyCode(item.getObjectPropertyCode());//sourceId:69330_2_9400
oneItem.setObjectPropertyName(item.getObjectPropertyName());//sourceId:69331_2_9400
oneItem.setMetaDataColumnContent(item.getMetaDataColumnContent());//sourceId:69332_2_9400
oneItem.setOriColumnContent(item.getOriColumnContent());//sourceId:69333_2_9400
oneItem.setColumnContent(item.getColumnContent());//sourceId:69334_2_9400
    }
if(reqDto!=null){
      oneItem.setSubjectTypeCode(reqDto.getSubjectTypeCode());//sourceId:69335_2_9400
oneItem.setSubjectChangeType(reqDto.getSubjectChangeType());//sourceId:69336_2_9400
oneItem.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:69338_2_9400
oneItem.setEntityName(reqDto.getEntityName());//sourceId:76957_2_9400
oneItem.setEntityId(reqDto.getEntityId());//sourceId:69339_2_9400
oneItem.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:69342_2_9400
oneItem.setObjectId(reqDto.getObjectId());//sourceId:69341_2_9400
oneItem.setBatchId(reqDto.getBatchId());//sourceId:76956_2_9400
oneItem.setBatchStartTime(reqDto.getBatchStartTime());//sourceId:69344_2_9400
oneItem.setBatchEndTime(reqDto.getBatchEndTime());//sourceId:69345_2_9400
oneItem.setIsEditing(reqDto.getIsEditing());//sourceId:69346_2_9400
oneItem.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:69347_2_9400
    }
               
                listChangeColumn_6.add(oneItem);
            }//sourceId:151587_1_9400
    }
  
    /*1-1-02批量新增底层变更字段[274]   */
    
      bOOLEAN_2 = mChangeColumnService.batchAddBaseChangeCol(listChangeColumn_6);
      
      
      
//virtualUsage 1-1-02批量改底层变更字段  9401
      boolean bOOLEAN_3 ;
    List<ChangeColumn> listChangeColumn_7=new ArrayList<>();
  if(dataAuClassificationRes!=null){
      listChangeColumn_7 = dataAuClassificationRes.getModifyColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumn.class)).collect(Collectors.toList());//sourceId:151651_1_9401
    }
  
    /*1-1-02批量改底层变更字段[1630]   */
    
      bOOLEAN_3 = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_7);
      
      
      
//virtualUsage D1-1生成变更记录语义内容(公共)  15278
      GenerateChangeColSemanticContentComRespDto generateChangeColSemanticContentComRespDto = null;
    GenerateChangeColSemanticContentComReqDto generateChangeColSemanticContentComReqDto=new GenerateChangeColSemanticContentComReqDto();
  if(reqDto!=null){
      generateChangeColSemanticContentComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:285821_1_15278
generateChangeColSemanticContentComReqDto.setEntityId(reqDto.getEntityId());//sourceId:285822_1_15278
generateChangeColSemanticContentComReqDto.setReviseSubjectContent(reqDto.getReviseSubjectContent());//sourceId:287416_1_15278
    }
  
    /*D1-1生成变更记录语义内容(公共)[4331]   */
    Assert.isNull(generateChangeColSemanticContentComReqDto.getTableTypeCode(),"D1-1修订底层框架服务变更字段-D1-1生成变更记录语义内容(公共)-内容表类型编码不能为空",false);
Assert.isNull(generateChangeColSemanticContentComReqDto.getEntityId(),"D1-1修订底层框架服务变更字段-D1-1生成变更记录语义内容(公共)-内容表主键ID不能为空",false);
Assert.isNull(generateChangeColSemanticContentComReqDto.getReviseSubjectContent(),"D1-1修订底层框架服务变更字段-D1-1生成变更记录语义内容(公共)-修订主体内容不能为空",false);
      generateChangeColSemanticContentComRespDto = generateChangeColSemanticContentCom(generateChangeColSemanticContentComReqDto);
      
      
      
//processBranchName:正常结束 ,processBranchId:12564
        
ReviseBaseChangeColRespDto retData = new ReviseBaseChangeColRespDto();
  
  

  
  
return retData;
  }

    /**
   * D1-1查询底层框架服务变更字段列表[934]
   * gen by moon at 10/2/2022, 7:51:07 AM
   */
  @Trace(operationName = "D1-1查询底层框架服务变更字段列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryBaseChangeColListRespDto queryBaseChangeColList(QueryBaseChangeColListReqDto reqDto){


      List<ChangeColumn> listChangeColumn_1 =new ArrayList<>();
//步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
     List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:18304_1
queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:18308_1
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23616_1
queryBaseChangeColListReq.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23617_1
if(reqDto!=null){
      queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:18293_1
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:18294_1
    }

    /*1-1-02查询底层变更字段列表[8]   */
    Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(),"D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getEntityId(),"D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getIsInproperties(),"D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-创建于空间ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getAppId(),"D1-1查询底层框架服务变更字段列表-1-1-02查询底层变更字段列表-创建于联盟应用ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);


      listChangeColumn_1 = listChangeColumn;

QueryBaseChangeColListRespDto retData = new QueryBaseChangeColListRespDto();
  retData.setBaseChangeColumnList(listChangeColumn_1.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.base.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:18312_1




return retData;
  }
/**
   * D1-1查询底层变更记录列表[3494]
   * gen by moon at 10/2/2022, 3:28:37 AM
   */
  @Trace(operationName = "D1-1查询底层变更记录列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryBaseChangeRecordListRespDto queryBaseChangeRecordList(QueryBaseChangeRecordListReqDto reqDto){
    
      
      List<ChangeColumn> listChangeColumn_1 =new ArrayList<>();
//步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
     List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:148707_1
if(reqDto!=null){
      queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:148497_1
queryBaseChangeColListReq.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:148892_1
queryBaseChangeColListReq.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:148709_1
queryBaseChangeColListReq.setSubjectUpdateStatus(reqDto.getSubjectUpdateStatus());//SimpleFieldAssign//sourceId:148893_1
queryBaseChangeColListReq.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:148890_1
queryBaseChangeColListReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:148891_1
queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:148888_1
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:148889_1
    }
  
    /*1-1-02查询底层变更字段列表[8]   */
    Assert.isNull(queryBaseChangeColListReq.getSubjectTypeCode(),"D1-1查询底层变更记录列表-1-1-02查询底层变更字段列表-主体类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-1查询底层变更记录列表-1-1-02查询底层变更字段列表-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
      

      listChangeColumn_1 = listChangeColumn;
    
QueryBaseChangeRecordListRespDto retData = new QueryBaseChangeRecordListRespDto();
  retData.setBaseChangeColumnList(listChangeColumn_1.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.base.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:148714_1
  

  
  
return retData;
  }
/**
   * D1-1新增底层变更字段(公共)[3533]
   * gen by moon at 8/24/2023, 1:19:26 PM
   */
  @Trace(operationName = "D1-1新增底层变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddBaseChangeColComRespDto addBaseChangeColCom(AddBaseChangeColComReqDto reqDto){
    
      
      //步骤0: M1-自动生成语义内容（特殊方法） - autoAenerateSemanticContent
     //ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes = null;
    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq=new AutoAenerateSemanticContentReqDto();
  if(reqDto!=null){
      generateSemanticInstanceReq.setAddBehaviorName(reqDto.getObjectPropertyName());//SimpleFieldAssign//sourceId:287382_1
generateSemanticInstanceReq.setAddSubjectContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:287385_1
generateSemanticInstanceReq.setSubjectContAffiliationParentCont(reqDto.getSubjectContAffiliationParentCont());//SimpleFieldAssign//sourceId:287383_1
    }
  
    /*M1-本次新增变更字段语义故事[3975]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq.getAddBehaviorName(),"D1-1新增底层变更字段(公共)-M1-本次新增变更字段语义故事-新增行为名称不能为空",false);
Assert.isNull(generateSemanticInstanceReq.getAddSubjectContent(),"D1-1新增底层变更字段(公共)-M1-本次新增变更字段语义故事-新增主体内容不能为空",false);
      generateSemanticInstanceRes = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq);
      
      
      
    
//步骤1: 1-1-02新增底层框架服务变更字段 - addBaseChangeColumn
     String string = null;
    ChangeColumn changeColumn=new ChangeColumn();
  changeColumn.setIsInproperties("FALSE");//sourceId:154344_1
changeColumn.setSubjectUpdateStatus("NEW");//sourceId:154394_1
if(reqDto!=null){
      changeColumn.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:154341_1
changeColumn.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:162131_1
changeColumn.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:154342_1
changeColumn.setObjectPropertyCode(reqDto.getObjectPropertyCode());//SimpleFieldAssign//sourceId:154339_1
changeColumn.setMetaDataColumnContent(reqDto.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:154340_1
changeColumn.setColumnContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:154389_1
changeColumn.setOriColumnContent(reqDto.getOriColumnContent());//SimpleFieldAssign//sourceId:154390_1
changeColumn.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:154391_1
changeColumn.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:154345_1
changeColumn.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:154392_1
changeColumn.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:154393_1
changeColumn.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:154395_1
changeColumn.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:154396_1
changeColumn.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:154397_1
changeColumn.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:154398_1
changeColumn.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:154405_1
    }
if(generateSemanticInstanceRes!=null){
      changeColumn.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:154388_1
    }
  
    /*1-1-02新增底层框架服务变更字段[5]   */
    Assert.isNull(changeColumn.getTableTypeCode(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空",false);
Assert.isNull(changeColumn.getEntityName(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn.getEntityId(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空",false);
Assert.isNull(changeColumn.getObjectPropertyCode(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn.getObjectPropertyName(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn.getMetaDataColumnContent(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段原始值不能为空",false);
Assert.isNull(changeColumn.getColumnContent(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更后字段中文内容不能为空",false);
Assert.isNull(changeColumn.getOriColumnContent(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更前字段中文内容不能为空",false);
Assert.isNull(changeColumn.getIsInproperties(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空",false);
Assert.isNull(changeColumn.getSubjectUpdateStatus(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn.getIsEditing(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn.getSubjectLifeCycle(),"D1-1新增底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空",false);
      string = mChangeColumnService.addBaseChangeColumn(changeColumn)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
AddBaseChangeColComRespDto retData = new AddBaseChangeColComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1存档底层变更字段(公共)[3535]
   * gen by moon at 9/20/2023, 11:29:53 PM
   */
  @Trace(operationName = "D1-1存档底层变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ArchiveBaseChangeColComRespDto archiveBaseChangeColCom(ArchiveBaseChangeColComReqDto reqDto){
    
      
      //virtualUsage M1-构造存档日志故事  15330
      //ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes = null;
    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq=new AutoAenerateSemanticContentReqDto();
  if(reqDto!=null){
      generateSemanticInstanceReq.setArchiveBehaviorName(reqDto.getObjectPropertyName());//SimpleFieldAssign//sourceId:287369_1_15330
generateSemanticInstanceReq.setArchiveSubjectContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:287366_1_15330
generateSemanticInstanceReq.setSubjectContAffiliationParentCont(reqDto.getSubjectContAffiliationParentCont());//SimpleFieldAssign//sourceId:287368_1_15330
    }
  
    /*M1-构造存档日志故事[3975]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq.getArchiveBehaviorName(),"D1-1存档底层变更字段(公共)-M1-构造存档日志故事-存档行为名称不能为空",false);
Assert.isNull(generateSemanticInstanceReq.getArchiveSubjectContent(),"D1-1存档底层变更字段(公共)-M1-构造存档日志故事-存档主体内容不能为空",false);
      generateSemanticInstanceRes = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq);
      
      
      
if((reqDto!= null&& reqDto.getBatchId() != null )) {
        //if(D1-1存档底层变更字段(公共).批次ID 值不等于空 )  9465
        
String string = null;
    ChangeColumn changeColumn=new ChangeColumn();
  changeColumn.setIsInproperties("FALSE");//sourceId:181393_1_11775
changeColumn.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:181401_1_11775
changeColumn.setSubjectUpdateStatus("ARCHIVE");//sourceId:181398_1_11775
changeColumn.setIsEditing("TRUE");//sourceId:181402_1_11775
changeColumn.setSubjectLifeCycle("EDITING");//sourceId:181403_1_11775
if(reqDto!=null){
      changeColumn.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:181385_1_11775
changeColumn.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:181386_1_11775
changeColumn.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:181387_1_11775
changeColumn.setObjectPropertyCode(reqDto.getObjectPropertyCode());//SimpleFieldAssign//sourceId:181388_1_11775
changeColumn.setMetaDataColumnContent(reqDto.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:181390_1_11775
changeColumn.setColumnContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:181391_1_11775
changeColumn.setOriColumnContent(reqDto.getOriColumnContent());//SimpleFieldAssign//sourceId:181392_1_11775
changeColumn.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:181394_1_11775
changeColumn.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:181395_1_11775
changeColumn.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:181396_1_11775
changeColumn.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:181397_1_11775
changeColumn.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:181399_1_11775
    }
if(generateSemanticInstanceRes!=null){
      changeColumn.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:181389_1_11775
    }
  
    /*1-1-02新增底层变更字段（用于想存档日志）[5]   */
    Assert.isNull(changeColumn.getTableTypeCode(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-内容表类型编码不能为空",false);
Assert.isNull(changeColumn.getEntityName(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn.getEntityId(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-内容表主键ID不能为空",false);
Assert.isNull(changeColumn.getObjectPropertyCode(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更字段英文名不能为空",false);
Assert.isNull(changeColumn.getObjectPropertyName(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn.getMetaDataColumnContent(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更字段原始值不能为空",false);
Assert.isNull(changeColumn.getColumnContent(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更后字段中文内容不能为空",false);
Assert.isNull(changeColumn.getOriColumnContent(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-变更前字段中文内容不能为空",false);
Assert.isNull(changeColumn.getIsInproperties(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-是否内部属性不能为空",false);
Assert.isNull(changeColumn.getSubjectTypeCode(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-主体类型编码不能为空",false);
Assert.isNull(changeColumn.getSubjectChangeType(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn.getObjectTypeCode(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn.getObjectId(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn.getBatchEndTime(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-批次结束时间不能为空",false);
Assert.isNull(changeColumn.getSubjectUpdateStatus(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn.getIsEditing(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-是否未来不能为空",false);
Assert.isNull(changeColumn.getSubjectLifeCycle(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（用于想存档日志）-主体生命周期不能为空",false);
      string = mChangeColumnService.addBaseChangeColumn(changeColumn)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//processBranchName:正常结束 ,processBranchId:9471
        
      }
else if((reqDto!= null&& reqDto.getBatchId() == null )){
       //elseif(D1-1存档底层变更字段(公共).批次ID 值等于空 )  11781
      
String string_2 = null;
    ChangeColumn changeColumn_1=new ChangeColumn();
  changeColumn_1.setIsInproperties("TRUE");//sourceId:181518_1_11782
changeColumn_1.setSubjectUpdateStatus("ARCHIVE");//sourceId:181525_1_11782
changeColumn_1.setIsEditing("FALSE");//sourceId:285502_1_11782
changeColumn_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:181517_1_11782
if(reqDto!=null){
      changeColumn_1.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:181513_1_11782
changeColumn_1.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:181530_1_11782
changeColumn_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:181514_1_11782
changeColumn_1.setObjectPropertyCode(reqDto.getObjectPropertyCode());//SimpleFieldAssign//sourceId:181511_1_11782
changeColumn_1.setMetaDataColumnContent(reqDto.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:181512_1_11782
changeColumn_1.setColumnContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:181523_1_11782
changeColumn_1.setOriColumnContent(reqDto.getOriColumnContent());//SimpleFieldAssign//sourceId:181522_1_11782
changeColumn_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:181524_1_11782
changeColumn_1.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:181519_1_11782
changeColumn_1.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:181527_1_11782
changeColumn_1.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:181526_1_11782
    }
if(generateSemanticInstanceRes!=null){
      changeColumn_1.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:181521_1_11782
    }
  
    /*1-1-02新增底层变更字段（非批次直接存档）[5]   */
    Assert.isNull(changeColumn_1.getTableTypeCode(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-内容表类型编码不能为空",false);
Assert.isNull(changeColumn_1.getEntityName(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn_1.getEntityId(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-内容表主键ID不能为空",false);
Assert.isNull(changeColumn_1.getObjectPropertyCode(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_1.getObjectPropertyName(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_1.getMetaDataColumnContent(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更字段原始值不能为空",false);
Assert.isNull(changeColumn_1.getColumnContent(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更后字段中文内容不能为空",false);
Assert.isNull(changeColumn_1.getOriColumnContent(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-变更前字段中文内容不能为空",false);
Assert.isNull(changeColumn_1.getIsInproperties(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-是否内部属性不能为空",false);
Assert.isNull(changeColumn_1.getSubjectTypeCode(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-主体类型编码不能为空",false);
Assert.isNull(changeColumn_1.getSubjectChangeType(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn_1.getObjectTypeCode(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn_1.getObjectId(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn_1.getSubjectUpdateStatus(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn_1.getIsEditing(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-是否未来不能为空",false);
Assert.isNull(changeColumn_1.getSubjectLifeCycle(),"D1-1存档底层变更字段(公共)-1-1-02新增底层变更字段（非批次直接存档）-主体生命周期不能为空",false);
      string_2 = mChangeColumnService.addBaseChangeColumn(changeColumn_1)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//processBranchName:正常结束 ,processBranchId:11783
        
    }
ArchiveBaseChangeColComRespDto retData = new ArchiveBaseChangeColComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1批量删底层变更字段(公共)[3540]
   * gen by moon at 9/20/2023, 11:32:33 PM
   */
  @Trace(operationName = "D1-1批量删底层变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchDeleteBaseChangeColComRespDto batchDeleteBaseChangeColCom(BatchDeleteBaseChangeColComReqDto reqDto){
    
      
      //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
     List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:155172_1
if(reqDto!=null){
      queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:155169_1
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:155170_1
    }
  
    /*1-1-02查询底层变更字段列表[8]   */
    Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(),"D1-1批量删底层变更字段(公共)-1-1-02查询底层变更字段列表-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getEntityId(),"D1-1批量删底层变更字段(公共)-1-1-02查询底层变更字段列表-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-1批量删底层变更字段(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤1: 1-1-02批量删除底层框架服务变更字段 - batchDeleteBaseChangeColumn	
     boolean bOOLEAN ;
    if(listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)&& listChangeColumn.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listChangeColumn!= null&& !CollectionUtil.isEmpty(listChangeColumn)&&  listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)){
  listString = listChangeColumn.stream().map(item->item.getChangeColumnId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:155183_1
    }

    /*1-1-02批量删除底层框架服务变更字段[7]   */
    
      bOOLEAN = mChangeColumnService.batchDeleteBaseChangeColumn(listString)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
BatchDeleteBaseChangeColComRespDto retData = new BatchDeleteBaseChangeColComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1撤销修订组织架构批次处理变更字段(公共)[3743]
   * gen by moon at 10/1/2022, 11:48:17 PM
   */
  @Trace(operationName = "D1-1撤销修订组织架构批次处理变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UndoReviseOrgBatchHandleChangeColComRespDto undoReviseOrgBatchHandleChangeColCom(UndoReviseOrgBatchHandleChangeColComReqDto reqDto){
    
      
      //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
     List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:320737_1
if(reqDto!=null){
      queryBaseChangeColListReq.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:176391_1
queryBaseChangeColListReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:176392_1
queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:176305_1
    }
  
    /*1-1-02查正在编辑底层框架变更字段[8]   */
    Assert.isNull(queryBaseChangeColListReq.getObjectTypeCode(),"D1-1撤销修订组织架构批次处理变更字段(公共)-1-1-02查正在编辑底层框架变更字段-归属对象类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getObjectId(),"D1-1撤销修订组织架构批次处理变更字段(公共)-1-1-02查正在编辑底层框架变更字段-归属对象内容ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getBatchId(),"D1-1撤销修订组织架构批次处理变更字段(公共)-1-1-02查正在编辑底层框架变更字段-批次ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1-1撤销修订组织架构批次处理变更字段(公共)-1-1-02查正在编辑底层框架变更字段-主体生命周期不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
      
      
      
    
//步骤1: 1-1-02批量删除底层框架服务变更字段 - batchDeleteBaseChangeColumn	
     boolean bOOLEAN ;
    if(listChangeColumn !=null&& listChangeColumn.size()>0 ){
          List<String> listString=new ArrayList<>();
  listString = listChangeColumn.stream().map(item->item.getChangeColumnId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:176194_1
  
    /*1-1-02批量删除底层框架服务变更字段[7]   */
    
      bOOLEAN = mChangeColumnService.batchDeleteBaseChangeColumn(listString);
      
      
      
           }
    
UndoReviseOrgBatchHandleChangeColComRespDto retData = new UndoReviseOrgBatchHandleChangeColComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1更新批次处理组织架构变更字段(公共)[3742]
   * gen by moon at 9/20/2023, 11:29:24 PM
   */
  @Trace(operationName = "D1-1更新批次处理组织架构变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public RefreshBatchProcessingOrgChangeColComRespDto refreshBatchProcessingOrgChangeColCom(RefreshBatchProcessingOrgChangeColComReqDto reqDto){
    
      
      //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
     List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:284969_1
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:284970_1
if(reqDto!=null){
      queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:284968_1
queryBaseChangeColListReq.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:284966_1
queryBaseChangeColListReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:284967_1
    }
  
    /*1-1-02查询正在编辑底层变更字段列表（用于发布生效）[8]   */
    Assert.isNull(queryBaseChangeColListReq.getBatchId(),"D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-批次ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getObjectTypeCode(),"D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-归属对象类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getObjectId(),"D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-归属对象内容ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-1更新批次处理组织架构变更字段(公共)-1-1-02查询正在编辑底层变更字段列表（用于发布生效）-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤1: 1-1-02批量改底层变更字段 - batchUpdateBaseChangeCol
     boolean bOOLEAN ;
    if(listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)&& listChangeColumn.size()>0 ){
          List<ChangeColumn> listChangeColumn_2=new ArrayList<>();
  if(listChangeColumn!= null&& !CollectionUtil.isEmpty(listChangeColumn)&&  listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)){
  listChangeColumn_2 = listChangeColumn.stream().map(item -> {
        ChangeColumn elm =BeanUtil.toBean(item, ChangeColumn.class);
        elm.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME
elm.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME
elm.setIsEditing("FALSE");
elm.setIsArchive("FALSE");
elm.setArchivngType("NOT_ARCHIVE");
elm.setSubjectLifeCycle("CURRENTLY_VALID");
elm.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID
elm.setReleaseTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME

        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:176142_1
    }

    /*1-1-02批量改底层框架变更字段为当前有效[1630]   */
    
      bOOLEAN = mChangeColumnService.batchUpdateBaseChangeCol(listChangeColumn_2)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
//步骤2: D1批量回写底层变更字段(公共) - batchWriteBackBaseChangeColCom
     BatchWriteBackBaseChangeColComRespDto batchWriteBackBaseChangeColComRespDto = null;
    BatchWriteBackBaseChangeColComReqDto batchWriteBackBaseChangeColComReqDto=new BatchWriteBackBaseChangeColComReqDto();
  batchWriteBackBaseChangeColComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:306218_1
if(reqDto!=null){
      batchWriteBackBaseChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:306213_1
batchWriteBackBaseChangeColComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:306216_1
batchWriteBackBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:306217_1
    }
  
    /*D1批量回写底层变更字段(公共)[4382]   */
    Assert.isNull(batchWriteBackBaseChangeColComReqDto.getBatchId(),"D1-1更新批次处理组织架构变更字段(公共)-D1批量回写底层变更字段(公共)-批次ID不能为空",false);
Assert.isNull(batchWriteBackBaseChangeColComReqDto.getObjectTypeCode(),"D1-1更新批次处理组织架构变更字段(公共)-D1批量回写底层变更字段(公共)-归属对象类型编码不能为空",false);
Assert.isNull(batchWriteBackBaseChangeColComReqDto.getObjectId(),"D1-1更新批次处理组织架构变更字段(公共)-D1批量回写底层变更字段(公共)-归属对象内容ID不能为空",false);
Assert.isNull(batchWriteBackBaseChangeColComReqDto.getSubjectLifeCycle(),"D1-1更新批次处理组织架构变更字段(公共)-D1批量回写底层变更字段(公共)-主体生命周期不能为空",false);
      batchWriteBackBaseChangeColComRespDto = batchWriteBackBaseChangeColCom(batchWriteBackBaseChangeColComReqDto)/*vcase invoke 同服务,同domain*/;
      
      
      
    
RefreshBatchProcessingOrgChangeColComRespDto retData = new RefreshBatchProcessingOrgChangeColComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1修订底层变更字段(公共)[3921]
   * gen by moon at 9/13/2022, 3:33:33 AM
   */
  @Trace(operationName = "D1修订底层变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @BanAuto
  @Override
  public ReviseBaseChangeColComRespDto reviseBaseChangeColCom(ReviseBaseChangeColComReqDto reqDto){
    
      
      ImplementBaseContentDetailsMergeFieldsRespDto mergeChangeColumnDetailRes_1 =null;
//virtualUsage 1-1-02查询底层变更字段列表  15913
      List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:197733_1_15913
queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:197714_1_15913
queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:197710_1_15913
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:197707_1_15913
if(reqDto!=null){
      queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:197704_1_15913
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//sourceId:197705_1_15913
    }
  
    /*1-1-02查询底层变更字段列表[8]   */
    Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(),"D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getEntityId(),"D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getIsInproperties(),"D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(),"D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1修订底层变更字段(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
      
      
      
if((listChangeColumn!= null&&  listChangeColumn !=null && listChangeColumn.size()>=0)) {
        //if(1-1-02查询底层变更字段列表.底层框架服务变更字段列表数据集条数 大于等于 0)  15914
        
//ModelCode: mergeChangeColumnDetail
        ImplementBaseContentDetailsMergeFieldsRespDto mergeChangeColumnDetailRes = null;
//    if(listChangeColumn !=null&& listChangeColumn.size()>0 ){
          ImplementBaseContentDetailsMergeFieldsReqDto mergeChangeColumnDetailReq=new ImplementBaseContentDetailsMergeFieldsReqDto();
  mergeChangeColumnDetailReq.setBaseChangeColList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, BaseChangeColDto.class)).collect(Collectors.toList()));//sourceId:197607_1_15915
if(reqDto!=null){
      mergeChangeColumnDetailReq.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//sourceId:197609_1_15915
mergeChangeColumnDetailReq.setPositionGradeId(reqDto.getPositionGradeId());//sourceId:200800_1_15915
mergeChangeColumnDetailReq.setStationId(reqDto.getStationId());//sourceId:200801_1_15915
mergeChangeColumnDetailReq.setTypeDictionaryId(reqDto.getTypeDictionaryId());//sourceId:200802_1_15915
mergeChangeColumnDetailReq.setPositionDutyDesc(reqDto.getPositionDutyDesc());//sourceId:200803_1_15915
mergeChangeColumnDetailReq.setPositionTargetDesc(reqDto.getPositionTargetDesc());//sourceId:200804_1_15915
mergeChangeColumnDetailReq.setRoleMemberId(reqDto.getRoleMemberId());//sourceId:308023_1_15915
//mergeChangeColumnDetailReq.setDirectorInductionId(reqDto.getDirectorInductionId());//sourceId:308024_1_15915
mergeChangeColumnDetailReq.setDeptNumber(reqDto.getDeptNumber());//sourceId:308025_1_15915
mergeChangeColumnDetailReq.setDeptName(reqDto.getDeptName());//sourceId:308026_1_15915
mergeChangeColumnDetailReq.setDeptEnName(reqDto.getDeptEnName());//sourceId:308027_1_15915
mergeChangeColumnDetailReq.setDeptShortName(reqDto.getDeptShortName());//sourceId:308028_1_15915
mergeChangeColumnDetailReq.setDeptDutyDesc(reqDto.getDeptDutyDesc());//sourceId:308029_1_15915
mergeChangeColumnDetailReq.setDeptTargetDesc(reqDto.getDeptTargetDesc());//sourceId:308030_1_15915
    }
  
    /*M1执行底层内容详情合并字段（特殊方法）[3534]  通过合并标识，将第二个数据集的数据覆盖第一个入参的数据 */
    
      mergeChangeColumnDetailRes = nbChangeColumn.implementBaseContentDetailsMergeFields(mergeChangeColumnDetailReq);
      
      
      mergeChangeColumnDetailRes_1 = mergeChangeColumnDetailRes;
           }
//processBranchName:正常结束 ,processBranchId:15916
        
//      }
ReviseBaseChangeColComRespDto retData = new ReviseBaseChangeColComRespDto();
  if(mergeChangeColumnDetailRes_1!=null){
      retData.setDirectorInductionRecordId(mergeChangeColumnDetailRes_1.getDirectorInductionRecordId());//sourceId:197667_1
retData.setPositionGradeId(mergeChangeColumnDetailRes_1.getPositionGradeId());//sourceId:200845_1
retData.setStationId(mergeChangeColumnDetailRes_1.getStationId());//sourceId:200846_1
retData.setTypeDictionaryId(mergeChangeColumnDetailRes_1.getTypeDictionaryId());//sourceId:200847_1
retData.setPositionDutyDesc(mergeChangeColumnDetailRes_1.getPositionDutyDesc());//sourceId:200848_1
retData.setPositionTargetDesc(mergeChangeColumnDetailRes_1.getPositionTargetDesc());//sourceId:200849_1
retData.setRoleMemberId(mergeChangeColumnDetailRes_1.getRoleMemberId());//sourceId:308047_1
//retData.setDirectorInductionId(mergeChangeColumnDetailRes_1.getDirectorInductionId());//sourceId:308048_1
retData.setDeptNumber(mergeChangeColumnDetailRes_1.getDeptNumber());//sourceId:308049_1
retData.setDeptName(mergeChangeColumnDetailRes_1.getDeptName());//sourceId:308050_1
retData.setDeptEnName(mergeChangeColumnDetailRes_1.getDeptEnName());//sourceId:308051_1
retData.setDeptShortName(mergeChangeColumnDetailRes_1.getDeptShortName());//sourceId:308052_1
retData.setDeptDutyDesc(mergeChangeColumnDetailRes_1.getDeptDutyDesc());//sourceId:308053_1
retData.setDeptTargetDesc(mergeChangeColumnDetailRes_1.getDeptTargetDesc());//sourceId:308054_1
    }
  

  
  
return retData;
  }
/**
   * D1-1撤销存档底层变更字段(公共)[3802]
   * gen by moon at 10/1/2022, 11:53:03 PM
   */
  @Trace(operationName = "D1-1撤销存档底层变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UndoArchiveBaseChangeColComRespDto undoArchiveBaseChangeColCom(UndoArchiveBaseChangeColComReqDto reqDto){
    
      
      //步骤0: 1-1-02查询底层变更字段详情 - queryBaseChangeColDetail
     ChangeColumn changeColumn = null;
    QueryBaseChangeColDetailReq queryBaseChangeColDetailReq=new QueryBaseChangeColDetailReq();
  queryBaseChangeColDetailReq.setIsInproperties("FALSE");//sourceId:181630_1
queryBaseChangeColDetailReq.setSubjectUpdateStatus("ARCHIVE");//sourceId:181634_1
queryBaseChangeColDetailReq.setSubjectLifeCycle("EDITING");//sourceId:181631_1
if(reqDto!=null){
      queryBaseChangeColDetailReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:181628_1
queryBaseChangeColDetailReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:181629_1
    }
  
    /*1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）[3536]   */
    Assert.isNull(queryBaseChangeColDetailReq.getTableTypeCode(),"D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColDetailReq.getEntityId(),"D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColDetailReq.getIsInproperties(),"D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColDetailReq.getSubjectUpdateStatus(),"D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-主体批次下更新状态不能为空",false);
Assert.isNull(queryBaseChangeColDetailReq.getSubjectLifeCycle(),"D1-1撤销存档底层变更字段(公共)-1-1-02查询本次存档的变更字段（在变更字段表是正在编辑）-主体生命周期不能为空",false);
      changeColumn = mChangeColumnService.queryBaseChangeColDetail(queryBaseChangeColDetailReq);
      
      
      
    
//步骤1: 1-1-02删除底层框架服务变更字段 - deleteBaseChangeColumn
     boolean bOOLEAN ;
    if(changeColumn !=null){
          String string=new String();
  if(changeColumn!=null){
      string=changeColumn.getChangeColumnId();;//SimpleFieldAssign//sourceId:181635_1
    }
  
    /*1-1-02删除底层变更字段（用于主表主键存档撤销）[917]   */
    Assert.isNull(string,"D1-1撤销存档底层变更字段(公共)-1-1-02删除底层变更字段（用于主表主键存档撤销）-变更字段记录ID不能为空",false);
      bOOLEAN = mChangeColumnService.deleteBaseChangeColumn(string);
      
      
      
           }
    
UndoArchiveBaseChangeColComRespDto retData = new UndoArchiveBaseChangeColComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1生成变更记录语义内容(公共)[4331]
   * gen by moon at 9/3/2022, 5:59:55 PM
   */
  @Trace(operationName = "D1-1生成变更记录语义内容(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public GenerateChangeColSemanticContentComRespDto generateChangeColSemanticContentCom(GenerateChangeColSemanticContentComReqDto reqDto){
    
      
      //步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
     List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:285804_1
queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:285704_1
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:285697_1
if(reqDto!=null){
      queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//sourceId:302241_1
queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:285694_1
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//sourceId:285695_1
queryBaseChangeColListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:287643_1
    }
  
    /*1-1-02查询底层变更字段列表[8]   */
    Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(),"D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getEntityId(),"D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getIsInproperties(),"D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(),"D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-1生成变更记录语义内容(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
      
      
      
    
//步骤1: M1-1-02执行变更字段【循环开始】 - implementChangeColLoopStart
     //ModelCode: circulationCollections
        for (ChangeColumn circulationCollectionsRes: listChangeColumn){ 
      
    
//步骤2: M1-自动生成语义内容（特殊方法） - autoAenerateSemanticContent
     //ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes = null;
    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq=new AutoAenerateSemanticContentReqDto();
  if(reqDto!=null){
      generateSemanticInstanceReq.setReviseSubjectContent(reqDto.getReviseSubjectContent());//sourceId:287411_1
    }
if(circulationCollectionsRes!=null){
      generateSemanticInstanceReq.setReviseBehaviorName(circulationCollectionsRes.getObjectPropertyName());//sourceId:287412_1
generateSemanticInstanceReq.setColumnContent(circulationCollectionsRes.getColumnContent());//sourceId:287414_1
    }
  
    /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq.getReviseSubjectContent(),"D1-1生成变更记录语义内容(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空",false);
Assert.isNull(generateSemanticInstanceReq.getReviseBehaviorName(),"D1-1生成变更记录语义内容(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空",false);
Assert.isNull(generateSemanticInstanceReq.getColumnContent(),"D1-1生成变更记录语义内容(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空",false);
      generateSemanticInstanceRes = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq);
      
      
      
    
//步骤3: 1-1-02修改底层变更字段 - updateBaseChangeCol
     boolean bOOLEAN ;
    ChangeColumn changeColumn=new ChangeColumn();
  if(circulationCollectionsRes!=null){
      changeColumn.setChangeColumnId(circulationCollectionsRes.getChangeColumnId());//sourceId:285816_1
    }
if(generateSemanticInstanceRes!=null){
      changeColumn.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//sourceId:285818_1
    }
  
    /*1-1-02修改底层变更字段（回写变更字段行为日志名称）[6]   */
    Assert.isNull(changeColumn.getChangeColumnId(),"D1-1生成变更记录语义内容(公共)-1-1-02修改底层变更字段（回写变更字段行为日志名称）-变更字段记录ID不能为空",false);
Assert.isNull(changeColumn.getObjectPropertyName(),"D1-1生成变更记录语义内容(公共)-1-1-02修改底层变更字段（回写变更字段行为日志名称）-变更字段行为日志名称不能为空",false);
      bOOLEAN = mChangeColumnService.updateBaseChangeCol(changeColumn);
      
      
      
    
//步骤4: M-循环结束（特殊方法） - addCycleCreate
     //ModelCode: circulationEnd
        }
      
    
GenerateChangeColSemanticContentComRespDto retData = new GenerateChangeColSemanticContentComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1修改底层变更字段(公共)[4335]
   * gen by moon at 1/24/2024, 7:08:44 PM
   */
  @Trace(operationName = "D1-1修改底层变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UpdateBaseChangeColComRespDto updateBaseChangeColCom(UpdateBaseChangeColComReqDto reqDto){
    
      
      //步骤0: 1-1-02查询底层变更字段详情 - queryBaseChangeColDetail
     ChangeColumn changeColumn = null;
    QueryBaseChangeColDetailReq queryBaseChangeColDetailReq=new QueryBaseChangeColDetailReq();
  queryBaseChangeColDetailReq.setIsInproperties("FALSE");//sourceId:286516_1
queryBaseChangeColDetailReq.setSubjectUpdateStatus("NEW");//sourceId:286520_1
queryBaseChangeColDetailReq.setSubjectLifeCycle("EDITING");//sourceId:286517_1
if(reqDto!=null){
      queryBaseChangeColDetailReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:286514_1
queryBaseChangeColDetailReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:286515_1
    }
  
    /*1-1-02查询底层变更字段（主体内容本次新增的变更字段）[3536]   */
    Assert.isNull(queryBaseChangeColDetailReq.getTableTypeCode(),"D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColDetailReq.getEntityId(),"D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColDetailReq.getIsInproperties(),"D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColDetailReq.getSubjectUpdateStatus(),"D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-主体批次下更新状态不能为空",false);
Assert.isNull(queryBaseChangeColDetailReq.getSubjectLifeCycle(),"D1-1修改底层变更字段(公共)-1-1-02查询底层变更字段（主体内容本次新增的变更字段）-主体生命周期不能为空",false);
      changeColumn = mChangeColumnService.queryBaseChangeColDetail(queryBaseChangeColDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤1: 1-1-02修改底层变更字段 - updateBaseChangeCol
     boolean bOOLEAN ;
    if(changeColumn !=null){
          ChangeColumn changeColumn_2=new ChangeColumn();
  if(changeColumn!=null){
      changeColumn_2.setChangeColumnId(changeColumn.getChangeColumnId());//SimpleFieldAssign//sourceId:286534_1
changeColumn_2.setOriColumnContent(changeColumn.getColumnContent());//SimpleFieldAssign//sourceId:286538_1
    }
if(reqDto!=null){
      changeColumn_2.setColumnContent(reqDto.getColumnContent());//SimpleFieldAssign//sourceId:286539_1
    }
  
    /*1-1-02修改底层变更字段[6]   */
    Assert.isNull(changeColumn_2.getChangeColumnId(),"D1-1修改底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空",false);
Assert.isNull(changeColumn_2.getOriColumnContent(),"D1-1修改底层变更字段(公共)-1-1-02修改底层变更字段-变更前字段中文内容不能为空",false);
Assert.isNull(changeColumn_2.getColumnContent(),"D1-1修改底层变更字段(公共)-1-1-02修改底层变更字段-变更后字段中文内容不能为空",false);
      bOOLEAN = mChangeColumnService.updateBaseChangeCol(changeColumn_2)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
UpdateBaseChangeColComRespDto retData = new UpdateBaseChangeColComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-判断重置修订元素(公共)[4343]
   * gen by moon at 9/2/2022, 2:58:12 PM
   */
  @Trace(operationName = "D1-判断重置修订元素(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeResetReviseElementComRespDto judgeResetReviseElementCom(JudgeResetReviseElementComReqDto reqDto){
    
      
      Long unknown_1 = null;
QueryReceiveFieldDetailRespDto receptionServiceRes_1 =null;
//virtualUsage 1-1-02查询底层变更字段列表  15374
      List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:287679_1_15374
queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:287680_1_15374
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:287681_1_15374
  
    /*1-1-02查询底层变更字段列表[8]   */
    Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(),"D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getEntityId(),"D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getIsInproperties(),"D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(),"D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-判断重置修订元素(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
      
      
      
if((listChangeColumn!= null&&  listChangeColumn !=null && listChangeColumn.size()>0)) {
        //if(1-1-02查询底层变更字段列表.底层框架服务变更字段列表数据集条数 大于 0)  15375
        
//Long unknown = null;
//    Object queryReceiveFieldDetailReq=new Object();
//  queryReceiveFieldDetailReq.setOutputNum(1);//CUSTOM_CONVENTION//sourceId:287875_1_15384
//
//    /*M1-允许重置修订[3715]   */
//    Assert.isNull(queryReceiveFieldDetailReq.getOutputNum(),"D1-判断重置修订元素(公共)-M1-允许重置修订-传输数值不能为空",false);
//      unknown = mCustomFields2Service.queryReceiveFieldDetail(queryReceiveFieldDetailReq);
//
//
//      unknown_1 = unknown;
//processBranchName:正常结束 ,processBranchId:15377

    QueryReceiveFieldDetailRespDto receptionServiceRes = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq=new QueryReceiveFieldDetailReqDto();
    receptionServiceReq.setOutputNum(1L);//CUSTOM_CONVENTION//sourceId:287778_1_15379

    /*M1-不允许重置修订[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOutputNum(),"D1-判断重置修订元素(公共)-M1-不允许重置修订-传输数值不能为空",false);
    receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);


    receptionServiceRes_1 = receptionServiceRes;
        
      }
else if((listChangeColumn!= null&&  listChangeColumn !=null && listChangeColumn.size()==0)){
       //elseif(1-1-02查询底层变更字段列表.底层框架服务变更字段列表数据集条数 等于 0)  15378
      
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq.setOutputNum(0L);//CUSTOM_CONVENTION//sourceId:287778_1_15379
  
    /*M1-不允许重置修订[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOutputNum(),"D1-判断重置修订元素(公共)-M1-不允许重置修订-传输数值不能为空",false);
      receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);
      
      
      receptionServiceRes_1 = receptionServiceRes;
//processBranchName:正常结束 ,processBranchId:15380
        
    }
JudgeResetReviseElementComRespDto retData = new JudgeResetReviseElementComRespDto();
if(receptionServiceRes_1!=null){
      retData.setResetRevise(receptionServiceRes_1.getOutputNum());//sourceId:287879_1
    }
  

  
  
return retData;
  }
/**
   * D1修订就职记录底层变更字段判断(公共)[4342]
   * gen by moon at 9/6/2022, 12:13:21 AM
   */
  @Trace(operationName = "D1修订就职记录底层变更字段判断(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReviseJudgeBaseChangeColComRespDto reviseJudgeBaseChangeColCom(ReviseJudgeBaseChangeColComReqDto reqDto){
    
      
      ReviseBaseChangeColComRespDto reviseBaseChangeColComRespDto_1 =null;
QueryReceiveFieldDetailRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
        //if(D1修订底层变更字段判断(公共).主体生命周期 等于 正在编辑)  15362
        
ReviseBaseChangeColComRespDto reviseBaseChangeColComRespDto = null;
    ReviseBaseChangeColComReqDto reviseBaseChangeColComReqDto=new ReviseBaseChangeColComReqDto();
  if(reqDto!=null){
      reviseBaseChangeColComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:287463_1_15363
reviseBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//sourceId:287464_1_15363
reviseBaseChangeColComReqDto.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//sourceId:287461_1_15363
    }
  
    /*D1修订底层变更字段(公共)[3921]   */
    Assert.isNull(reviseBaseChangeColComReqDto.getTableTypeCode(),"D1修订就职记录底层变更字段判断(公共)-D1修订底层变更字段(公共)-内容表类型编码不能为空",false);
Assert.isNull(reviseBaseChangeColComReqDto.getEntityId(),"D1修订就职记录底层变更字段判断(公共)-D1修订底层变更字段(公共)-内容表主键ID不能为空",false);
      reviseBaseChangeColComRespDto = reviseBaseChangeColCom(reviseBaseChangeColComReqDto);
      
      
      reviseBaseChangeColComRespDto_1 = reviseBaseChangeColComRespDto;
//processBranchName:正常结束 ,processBranchId:15366
        
      }
else{
       //else  15364
      
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq=new QueryReceiveFieldDetailReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//sourceId:307994_1_15752
    }
  
    /*M1-传输修订的字段原有值[3715]  用于特殊方法接收上游入参。 */
    
      receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);
      
      
      receptionServiceRes_1 = receptionServiceRes;
//processBranchName:正常结束 ,processBranchId:15365
        
    }
ReviseJudgeBaseChangeColComRespDto retData = new ReviseJudgeBaseChangeColComRespDto();
  if(reviseBaseChangeColComRespDto_1!=null){
      retData.setDirectorInductionRecordId(reviseBaseChangeColComRespDto_1.getDirectorInductionRecordId());//sourceId:287625_1
    }
if(receptionServiceRes_1!=null){
      retData.setDirectorInductionRecordId(receptionServiceRes_1.getDirectorInductionRecordId());//sourceId:287625_1
    }
  

  
  
return retData;
  }
/**
   * D1-1执行修订底层变更字段(公共)[272]
   * gen by moon at 10/24/2022, 9:43:47 PM
   */
  @Trace(operationName = "D1-1执行修订底层变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColCom(ImplementReviseBaseChangeColComReqDto reqDto){
    
      
      //virtualUsage 1-1-02查内容ID本次已更新字段列表（正在编辑）  15544
      List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:151656_1_15544
queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:23597_1_15544
queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:17175_1_15544
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23614_1_15544
if(reqDto!=null){
      queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:181698_1_15544
queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:17172_1_15544
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:17173_1_15544
    }
  
    /*1-1-02查内容ID本次已更新字段列表（正在编辑）[8]   */
    Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getEntityId(),"D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(),"D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体批次下更新状态不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getIsInproperties(),"D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-1执行修订底层变更字段(公共)-1-1-02查内容ID本次已更新字段列表（正在编辑）-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
      
      
      
if((reqDto!= null&& reqDto.getBatchId() != null )) {
        //if(D1-1执行修订底层变更字段(公共).批次ID 值不等于空 )  15547
        
if((listChangeColumn!= null&&  listChangeColumn !=null && listChangeColumn.size()==0)) {
        //if(1-1-02查内容ID本次已更新字段列表（正在编辑）.底层框架服务变更字段列表数据集条数 等于 0)  15551
        
//ModelCode: circulationCollections
        for (ChangeColumnDto circulationCollectionsRes: reqDto.getChangeColumnList()){ 
      
//ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes = null;
    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq=new AutoAenerateSemanticContentReqDto();
  if(reqDto!=null){
      generateSemanticInstanceReq.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15600
    }
if(circulationCollectionsRes!=null){
      generateSemanticInstanceReq.setReviseBehaviorName(circulationCollectionsRes.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15600
generateSemanticInstanceReq.setColumnContent(circulationCollectionsRes.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15600
    }
  
    /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq.getReviseSubjectContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空",false);
Assert.isNull(generateSemanticInstanceReq.getReviseBehaviorName(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空",false);
Assert.isNull(generateSemanticInstanceReq.getColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空",false);
      generateSemanticInstanceRes = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq);
      
      
      
if((circulationCollectionsRes!= null&& circulationCollectionsRes.getOriColumnContent() == null )) {
        //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  15646
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_15647
  
    /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空",false);
      receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);
      
      
      
String string = null;
    ChangeColumn changeColumn=new ChangeColumn();
  changeColumn.setIsInproperties("TRUE");//sourceId:304307_1_15648
changeColumn.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15648
if(reqDto!=null){
      changeColumn.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15648
changeColumn.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15648
changeColumn.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15648
changeColumn.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15648
changeColumn.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15648
changeColumn.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15648
changeColumn.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15648
changeColumn.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:304309_1_15648
changeColumn.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304317_1_15648
changeColumn.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304304_1_15648
changeColumn.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15648
changeColumn.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15648
    }
if(circulationCollectionsRes!=null){
      changeColumn.setObjectPropertyCode(circulationCollectionsRes.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15648
changeColumn.setMetaDataColumnContent(circulationCollectionsRes.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15648
changeColumn.setColumnContent(circulationCollectionsRes.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15648
    }
if(generateSemanticInstanceRes!=null){
      changeColumn.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15648
    }
if(receptionServiceRes!=null){
      changeColumn.setOriColumnContent(receptionServiceRes.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15648
    }
  
    /*1-1-02新增底层框架服务变更字段[5]   */
    Assert.isNull(changeColumn.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空",false);
Assert.isNull(changeColumn.getEntityName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn.getEntityId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空",false);
Assert.isNull(changeColumn.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn.getIsInproperties(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空",false);
Assert.isNull(changeColumn.getSubjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空",false);
Assert.isNull(changeColumn.getSubjectChangeType(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn.getObjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn.getObjectId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn.getSubjectUpdateStatus(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空",false);
      string = mChangeColumnService.addBaseChangeColumn(changeColumn);
      
      
      
      }
else{
       //else  15722

String string_2 = null;
    ChangeColumn changeColumn_1=new ChangeColumn();
  changeColumn_1.setIsInproperties("TRUE");//sourceId:304307_1_15723
changeColumn_1.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15723
if(reqDto!=null){
      changeColumn_1.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15723
changeColumn_1.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15723
changeColumn_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15723
changeColumn_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15723
changeColumn_1.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15723
changeColumn_1.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15723
changeColumn_1.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15723
changeColumn_1.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:304309_1_15723
changeColumn_1.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304317_1_15723
changeColumn_1.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304304_1_15723
changeColumn_1.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15723
changeColumn_1.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15723
    }
if(circulationCollectionsRes!=null){
      changeColumn_1.setObjectPropertyCode(circulationCollectionsRes.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15723
changeColumn_1.setMetaDataColumnContent(circulationCollectionsRes.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15723
changeColumn_1.setOriColumnContent(circulationCollectionsRes.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15723
changeColumn_1.setColumnContent(circulationCollectionsRes.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15723
    }
if(generateSemanticInstanceRes!=null){
      changeColumn_1.setObjectPropertyName(generateSemanticInstanceRes.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15723
    }

    /*1-1-02新增底层框架服务变更字段[5]   */
    Assert.isNull(changeColumn_1.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空",false);
Assert.isNull(changeColumn_1.getEntityName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn_1.getEntityId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空",false);
Assert.isNull(changeColumn_1.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_1.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_1.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_1.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_1.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_1.getIsInproperties(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空",false);
Assert.isNull(changeColumn_1.getSubjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空",false);
Assert.isNull(changeColumn_1.getSubjectChangeType(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn_1.getObjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn_1.getObjectId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn_1.getSubjectUpdateStatus(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn_1.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_1.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空",false);
      string_2 = mChangeColumnService.addBaseChangeColumn(changeColumn_1);
      
      
      
    }
//ModelCode: circulationEnd
        }
      
      }
else if((listChangeColumn!= null&&  listChangeColumn !=null && listChangeColumn.size()>0)){
       //elseif(1-1-02查内容ID本次已更新字段列表（正在编辑）.底层框架服务变更字段列表数据集条数 大于 0)  15552
      
//ModelCode: dataAuClassification
        FilterAddUpdateColumnRespDto dataAuClassificationRes = null;
    FilterAddUpdateColumnReqDto dataAuClassificationReq=new FilterAddUpdateColumnReqDto();
  if(listChangeColumn!= null&& !CollectionUtil.isEmpty(listChangeColumn)&&  listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)){
      dataAuClassificationReq.setBaseChangeColumnList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:151662_1_15554
    }
if(reqDto!= null&&  reqDto.getChangeColumnList() !=null&& !CollectionUtil.isEmpty(reqDto.getChangeColumnList())){
      dataAuClassificationReq.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:47370_1_15554
    }
  
    /*从更新字段中，分类出新增、修改字段（空方法）[908]  入参两个数据集，出参两个数据集，分别对应：新增数据集、删除数据集 */
    
      dataAuClassificationRes = nbChangeColumn.filterAddUpdateColumn(dataAuClassificationReq);
      
      
      
if((dataAuClassificationRes!= null&&  dataAuClassificationRes.getNewColumnList() !=null && dataAuClassificationRes.getNewColumnList().size()>0&&dataAuClassificationRes!= null&&  dataAuClassificationRes.getModifyColumnList() !=null && dataAuClassificationRes.getModifyColumnList().size()>=0)) {
        //if((从更新字段中，分类出新增、修改字段（空方法）.新增字段分类列表数据集条数 大于 0 and 从更新字段中，分类出新增、修改字段（空方法）.修改字段分类列表数据集条数 大于等于 0))  15555
        
//ModelCode: circulationCollections
        for (NewColumnDto circulationCollectionsRes_2: dataAuClassificationRes.getNewColumnList()){ 
      
//ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_2 = null;
    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_1=new AutoAenerateSemanticContentReqDto();
  if(reqDto!=null){
      generateSemanticInstanceReq_1.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15602
    }
if(circulationCollectionsRes_2!=null){
      generateSemanticInstanceReq_1.setReviseBehaviorName(circulationCollectionsRes_2.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15602
generateSemanticInstanceReq_1.setColumnContent(circulationCollectionsRes_2.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15602
    }
  
    /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq_1.getReviseSubjectContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空",false);
Assert.isNull(generateSemanticInstanceReq_1.getReviseBehaviorName(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空",false);
Assert.isNull(generateSemanticInstanceReq_1.getColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空",false);
      generateSemanticInstanceRes_2 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_1);
      
      
      
if((circulationCollectionsRes_2!= null&& circulationCollectionsRes_2.getOriColumnContent() == null )) {
        //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  15649
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_1=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_1.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_15650
  
    /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空",false);
      receptionServiceRes_2 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_1);
      
      
      
String string_3 = null;
    ChangeColumn changeColumn_2=new ChangeColumn();
  changeColumn_2.setIsInproperties("TRUE");//sourceId:304307_1_15651
changeColumn_2.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15651
if(reqDto!=null){
      changeColumn_2.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15651
changeColumn_2.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15651
changeColumn_2.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15651
changeColumn_2.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15651
changeColumn_2.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15651
changeColumn_2.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15651
changeColumn_2.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15651
changeColumn_2.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:304309_1_15651
changeColumn_2.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304317_1_15651
changeColumn_2.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304304_1_15651
changeColumn_2.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15651
changeColumn_2.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15651
    }
if(circulationCollectionsRes_2!=null){
      changeColumn_2.setObjectPropertyCode(circulationCollectionsRes_2.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15651
changeColumn_2.setMetaDataColumnContent(circulationCollectionsRes_2.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15651
changeColumn_2.setColumnContent(circulationCollectionsRes_2.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15651
    }
if(generateSemanticInstanceRes_2!=null){
      changeColumn_2.setObjectPropertyName(generateSemanticInstanceRes_2.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15651
    }
if(receptionServiceRes_2!=null){
      changeColumn_2.setOriColumnContent(receptionServiceRes_2.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15651
    }
  
    /*1-1-02新增底层框架服务变更字段[5]   */
    Assert.isNull(changeColumn_2.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空",false);
Assert.isNull(changeColumn_2.getEntityName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn_2.getEntityId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空",false);
Assert.isNull(changeColumn_2.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_2.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_2.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_2.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_2.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_2.getIsInproperties(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空",false);
Assert.isNull(changeColumn_2.getSubjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空",false);
Assert.isNull(changeColumn_2.getSubjectChangeType(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn_2.getObjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn_2.getObjectId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn_2.getSubjectUpdateStatus(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn_2.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_2.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空",false);
      string_3 = mChangeColumnService.addBaseChangeColumn(changeColumn_2);
      
      
      
      }
else{
       //else  15720

String string_4 = null;
    ChangeColumn changeColumn_3=new ChangeColumn();
  changeColumn_3.setIsInproperties("TRUE");//sourceId:304307_1_15721
changeColumn_3.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15721
if(reqDto!=null){
      changeColumn_3.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15721
changeColumn_3.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15721
changeColumn_3.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15721
changeColumn_3.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15721
changeColumn_3.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15721
changeColumn_3.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15721
changeColumn_3.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15721
changeColumn_3.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:304309_1_15721
changeColumn_3.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304317_1_15721
changeColumn_3.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304304_1_15721
changeColumn_3.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15721
changeColumn_3.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15721
    }
if(circulationCollectionsRes_2!=null){
      changeColumn_3.setObjectPropertyCode(circulationCollectionsRes_2.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15721
changeColumn_3.setMetaDataColumnContent(circulationCollectionsRes_2.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15721
changeColumn_3.setOriColumnContent(circulationCollectionsRes_2.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15721
changeColumn_3.setColumnContent(circulationCollectionsRes_2.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15721
    }
if(generateSemanticInstanceRes_2!=null){
      changeColumn_3.setObjectPropertyName(generateSemanticInstanceRes_2.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15721
    }

    /*1-1-02新增底层框架服务变更字段[5]   */
    Assert.isNull(changeColumn_3.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空",false);
Assert.isNull(changeColumn_3.getEntityName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn_3.getEntityId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空",false);
Assert.isNull(changeColumn_3.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_3.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_3.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_3.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_3.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_3.getIsInproperties(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空",false);
Assert.isNull(changeColumn_3.getSubjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空",false);
Assert.isNull(changeColumn_3.getSubjectChangeType(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn_3.getObjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn_3.getObjectId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn_3.getSubjectUpdateStatus(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn_3.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_3.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空",false);
      string_4 = mChangeColumnService.addBaseChangeColumn(changeColumn_3);
      
      
      
    }
//ModelCode: circulationEnd
        }
      
      }
if((dataAuClassificationRes!= null&&  dataAuClassificationRes.getModifyColumnList() !=null && dataAuClassificationRes.getModifyColumnList().size()>0&&dataAuClassificationRes!= null&&  dataAuClassificationRes.getNewColumnList() !=null && dataAuClassificationRes.getNewColumnList().size()>=0)) {
        //if((从更新字段中，分类出新增、修改字段（空方法）.修改字段分类列表数据集条数 大于 0 and 从更新字段中，分类出新增、修改字段（空方法）.新增字段分类列表数据集条数 大于等于 0))  15557
        
//ModelCode: circulationCollections
        for (ModifyColumnDto circulationCollectionsRes_3: dataAuClassificationRes.getModifyColumnList()){ 
      
//ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_3 = null;
    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_2=new AutoAenerateSemanticContentReqDto();
  if(reqDto!=null){
      generateSemanticInstanceReq_2.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15614
    }
if(circulationCollectionsRes_3!=null){
      generateSemanticInstanceReq_2.setReviseBehaviorName(circulationCollectionsRes_3.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15614
generateSemanticInstanceReq_2.setColumnContent(circulationCollectionsRes_3.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15614
    }
  
    /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq_2.getReviseSubjectContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空",false);
Assert.isNull(generateSemanticInstanceReq_2.getReviseBehaviorName(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空",false);
Assert.isNull(generateSemanticInstanceReq_2.getColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空",false);
      generateSemanticInstanceRes_3 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_2);
      
      
      
if((circulationCollectionsRes_3!= null&& circulationCollectionsRes_3.getOriColumnContent() == null )) {
        //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  16201

//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_3 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_2=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_2.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_16205

    /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空",false);
      receptionServiceRes_3 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_2);



boolean bOOLEAN ;
    ChangeColumn changeColumn_4=new ChangeColumn();
  changeColumn_4.setIsArchive("FALSE");//sourceId:304329_1_16203
changeColumn_4.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_16203
if(changeColumn_4!=null && changeColumn_4.getSubjectLifeCycle()!=null &&  changeColumn_4.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
            changeColumn_4.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
          }//sourceId:304326_1_16203
if(changeColumn_4!=null && changeColumn_4.getSubjectLifeCycle()!=null && changeColumn_4.getSubjectLifeCycle().equals("CURRENTLY_VALID")){
             changeColumn_4.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
            }//sourceId:304328_1_16203
if(circulationCollectionsRes_3!=null){
      changeColumn_4.setChangeColumnId(circulationCollectionsRes_3.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_16203
changeColumn_4.setObjectPropertyCode(circulationCollectionsRes_3.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_16203
changeColumn_4.setMetaDataColumnContent(circulationCollectionsRes_3.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_16203
changeColumn_4.setColumnContent(circulationCollectionsRes_3.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_16203
    }
if(generateSemanticInstanceRes_3!=null){
      changeColumn_4.setObjectPropertyName(generateSemanticInstanceRes_3.getObjectName());//SimpleFieldAssign//sourceId:304332_1_16203
    }
if(receptionServiceRes_3!=null){
      changeColumn_4.setOriColumnContent(receptionServiceRes_3.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_16203
    }
if(reqDto!=null){
      changeColumn_4.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304322_1_16203
changeColumn_4.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304323_1_16203
changeColumn_4.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_16203
changeColumn_4.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_16203
    }
  
    /*1-1-02修改底层变更字段[6]   */
    Assert.isNull(changeColumn_4.getChangeColumnId(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空",false);
Assert.isNull(changeColumn_4.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_4.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_4.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_4.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_4.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_4.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_4.getIsArchive(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空",false);
Assert.isNull(changeColumn_4.getArchivngType(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空",false);
Assert.isNull(changeColumn_4.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空",false);
      bOOLEAN = mChangeColumnService.updateBaseChangeCol(changeColumn_4);
      
      
      
      }
else{
       //else  16202

boolean bOOLEAN_1 ;
    ChangeColumn changeColumn_5=new ChangeColumn();
  changeColumn_5.setIsArchive("FALSE");//sourceId:304329_1_16204
changeColumn_5.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_16204
if(changeColumn_5!=null && changeColumn_5.getSubjectLifeCycle()!=null &&  changeColumn_5.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
            changeColumn_5.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
          }//sourceId:304326_1_16204
if(changeColumn_5!=null && changeColumn_5.getSubjectLifeCycle()!=null && changeColumn_5.getSubjectLifeCycle().equals("CURRENTLY_VALID")){
             changeColumn_5.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
            }//sourceId:304328_1_16204
if(circulationCollectionsRes_3!=null){
      changeColumn_5.setChangeColumnId(circulationCollectionsRes_3.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_16204
changeColumn_5.setObjectPropertyCode(circulationCollectionsRes_3.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_16204
changeColumn_5.setMetaDataColumnContent(circulationCollectionsRes_3.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_16204
changeColumn_5.setOriColumnContent(circulationCollectionsRes_3.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_16204
changeColumn_5.setColumnContent(circulationCollectionsRes_3.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_16204
    }
if(generateSemanticInstanceRes_3!=null){
      changeColumn_5.setObjectPropertyName(generateSemanticInstanceRes_3.getObjectName());//SimpleFieldAssign//sourceId:304332_1_16204
    }
if(reqDto!=null){
      changeColumn_5.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304322_1_16204
changeColumn_5.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304323_1_16204
changeColumn_5.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_16204
changeColumn_5.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_16204
    }

    /*1-1-02修改底层变更字段[6]   */
    Assert.isNull(changeColumn_5.getChangeColumnId(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空",false);
Assert.isNull(changeColumn_5.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_5.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_5.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_5.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_5.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_5.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_5.getIsArchive(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空",false);
Assert.isNull(changeColumn_5.getArchivngType(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空",false);
Assert.isNull(changeColumn_5.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空",false);
      bOOLEAN_1 = mChangeColumnService.updateBaseChangeCol(changeColumn_5);



    }
boolean bOOLEAN_2 ;
    ChangeColumn changeColumn_6=new ChangeColumn();
  changeColumn_6.setIsArchive("FALSE");//sourceId:304329_1_15615
changeColumn_6.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_15615
if(changeColumn_6!=null && changeColumn_6.getSubjectLifeCycle()!=null &&  changeColumn_6.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
            changeColumn_6.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
          }//sourceId:304326_1_15615
if(changeColumn_6!=null && changeColumn_6.getSubjectLifeCycle()!=null && changeColumn_6.getSubjectLifeCycle().equals("CURRENTLY_VALID")){
             changeColumn_6.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
            }//sourceId:304328_1_15615
if(circulationCollectionsRes_3!=null){
      changeColumn_6.setChangeColumnId(circulationCollectionsRes_3.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_15615
changeColumn_6.setObjectPropertyCode(circulationCollectionsRes_3.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_15615
changeColumn_6.setMetaDataColumnContent(circulationCollectionsRes_3.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_15615
changeColumn_6.setOriColumnContent(circulationCollectionsRes_3.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_15615
changeColumn_6.setColumnContent(circulationCollectionsRes_3.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_15615
    }
if(generateSemanticInstanceRes_3!=null){
      changeColumn_6.setObjectPropertyName(generateSemanticInstanceRes_3.getObjectName());//SimpleFieldAssign//sourceId:304332_1_15615
    }
if(reqDto!=null){
      changeColumn_6.setBatchStartTime(reqDto.getBatchStartTime());//SimpleFieldAssign//sourceId:304322_1_15615
changeColumn_6.setBatchEndTime(reqDto.getBatchEndTime());//SimpleFieldAssign//sourceId:304323_1_15615
changeColumn_6.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_15615
changeColumn_6.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_15615
    }

    /*1-1-02修改底层变更字段[6]   */
    Assert.isNull(changeColumn_6.getChangeColumnId(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空",false);
Assert.isNull(changeColumn_6.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_6.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_6.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_6.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_6.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_6.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_6.getIsArchive(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空",false);
Assert.isNull(changeColumn_6.getArchivngType(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空",false);
Assert.isNull(changeColumn_6.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空",false);
      bOOLEAN_2 = mChangeColumnService.updateBaseChangeCol(changeColumn_6);



//ModelCode: circulationEnd
        }
      
      }
    }
      }
else if((reqDto!= null&& reqDto.getBatchId() == null )){
       //elseif(D1-1执行修订底层变更字段(公共).批次ID 值等于空 )  15549
      
if((listChangeColumn!= null&&  listChangeColumn !=null && listChangeColumn.size()==0)) {
        //if(1-1-02查内容ID本次已更新字段列表（正在编辑）.底层框架服务变更字段列表数据集条数 等于 0)  15562
        
//ModelCode: circulationCollections
        for (ChangeColumnDto circulationCollectionsRes_4: reqDto.getChangeColumnList()){ 
      
//ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_4 = null;
    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_3=new AutoAenerateSemanticContentReqDto();
  if(reqDto!=null){
      generateSemanticInstanceReq_3.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15606
    }
if(circulationCollectionsRes_4!=null){
      generateSemanticInstanceReq_3.setReviseBehaviorName(circulationCollectionsRes_4.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15606
generateSemanticInstanceReq_3.setColumnContent(circulationCollectionsRes_4.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15606
    }
  
    /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq_3.getReviseSubjectContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空",false);
Assert.isNull(generateSemanticInstanceReq_3.getReviseBehaviorName(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空",false);
Assert.isNull(generateSemanticInstanceReq_3.getColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空",false);
      generateSemanticInstanceRes_4 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_3);
      
      
      
if((circulationCollectionsRes_4!= null&& circulationCollectionsRes_4.getOriColumnContent() == null )) {
        //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  15652
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_4 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_3=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_3.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_15653
  
    /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空",false);
      receptionServiceRes_4 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_3);
      
      
      
String string_5 = null;
    ChangeColumn changeColumn_7=new ChangeColumn();
  changeColumn_7.setIsInproperties("TRUE");//sourceId:304307_1_15654
changeColumn_7.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15654
if(reqDto!=null){
      changeColumn_7.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15654
changeColumn_7.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15654
changeColumn_7.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15654
changeColumn_7.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15654
changeColumn_7.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15654
changeColumn_7.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15654
changeColumn_7.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15654
changeColumn_7.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15654
changeColumn_7.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15654
    }
if(circulationCollectionsRes_4!=null){
      changeColumn_7.setObjectPropertyCode(circulationCollectionsRes_4.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15654
changeColumn_7.setMetaDataColumnContent(circulationCollectionsRes_4.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15654
changeColumn_7.setColumnContent(circulationCollectionsRes_4.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15654
    }
if(generateSemanticInstanceRes_4!=null){
      changeColumn_7.setObjectPropertyName(generateSemanticInstanceRes_4.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15654
    }
if(receptionServiceRes_4!=null){
      changeColumn_7.setOriColumnContent(receptionServiceRes_4.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15654
    }
  
    /*1-1-02新增底层框架服务变更字段[5]   */
    Assert.isNull(changeColumn_7.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空",false);
Assert.isNull(changeColumn_7.getEntityName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn_7.getEntityId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空",false);
Assert.isNull(changeColumn_7.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_7.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_7.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_7.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_7.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_7.getIsInproperties(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空",false);
Assert.isNull(changeColumn_7.getSubjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空",false);
Assert.isNull(changeColumn_7.getSubjectChangeType(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn_7.getObjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn_7.getObjectId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn_7.getSubjectUpdateStatus(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn_7.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_7.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空",false);
      string_5 = mChangeColumnService.addBaseChangeColumn(changeColumn_7);
      
      
      
      }
else{
       //else  15718

String string_6 = null;
    ChangeColumn changeColumn_8=new ChangeColumn();
  changeColumn_8.setIsInproperties("TRUE");//sourceId:304307_1_15719
changeColumn_8.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15719
if(reqDto!=null){
      changeColumn_8.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15719
changeColumn_8.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15719
changeColumn_8.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15719
changeColumn_8.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15719
changeColumn_8.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15719
changeColumn_8.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15719
changeColumn_8.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15719
changeColumn_8.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15719
changeColumn_8.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15719
    }
if(circulationCollectionsRes_4!=null){
      changeColumn_8.setObjectPropertyCode(circulationCollectionsRes_4.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15719
changeColumn_8.setMetaDataColumnContent(circulationCollectionsRes_4.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15719
changeColumn_8.setOriColumnContent(circulationCollectionsRes_4.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15719
changeColumn_8.setColumnContent(circulationCollectionsRes_4.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15719
    }
if(generateSemanticInstanceRes_4!=null){
      changeColumn_8.setObjectPropertyName(generateSemanticInstanceRes_4.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15719
    }

    /*1-1-02新增底层框架服务变更字段[5]   */
    Assert.isNull(changeColumn_8.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空",false);
Assert.isNull(changeColumn_8.getEntityName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn_8.getEntityId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空",false);
Assert.isNull(changeColumn_8.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_8.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_8.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_8.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_8.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_8.getIsInproperties(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空",false);
Assert.isNull(changeColumn_8.getSubjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空",false);
Assert.isNull(changeColumn_8.getSubjectChangeType(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn_8.getObjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn_8.getObjectId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn_8.getSubjectUpdateStatus(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn_8.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_8.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空",false);
      string_6 = mChangeColumnService.addBaseChangeColumn(changeColumn_8);
      
      
      
    }
//ModelCode: circulationEnd
        }
      
      }
else if((listChangeColumn!= null&&  listChangeColumn !=null && listChangeColumn.size()>0)){
       //elseif(1-1-02查内容ID本次已更新字段列表（正在编辑）.底层框架服务变更字段列表数据集条数 大于 0)  15563
      
//ModelCode: dataAuClassification
        FilterAddUpdateColumnRespDto dataAuClassificationRes_2 = null;
    FilterAddUpdateColumnReqDto dataAuClassificationReq_1=new FilterAddUpdateColumnReqDto();
  if(listChangeColumn!= null&& !CollectionUtil.isEmpty(listChangeColumn)&&  listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)){
      dataAuClassificationReq_1.setBaseChangeColumnList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:151662_1_15565
    }
if(reqDto!= null&&  reqDto.getChangeColumnList() !=null&& !CollectionUtil.isEmpty(reqDto.getChangeColumnList())){
      dataAuClassificationReq_1.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:47370_1_15565
    }
  
    /*从更新字段中，分类出新增、修改字段（空方法）[908]  入参两个数据集，出参两个数据集，分别对应：新增数据集、删除数据集 */
    
      dataAuClassificationRes_2 = nbChangeColumn.filterAddUpdateColumn(dataAuClassificationReq_1);
      
      
      
if((dataAuClassificationRes_2!= null&&  dataAuClassificationRes_2.getNewColumnList() !=null && dataAuClassificationRes_2.getNewColumnList().size()>0&&dataAuClassificationRes_2!= null&&  dataAuClassificationRes_2.getModifyColumnList() !=null && dataAuClassificationRes_2.getModifyColumnList().size()>=0)) {
        //if((从更新字段中，分类出新增、修改字段（空方法）.新增字段分类列表数据集条数 大于 0 and 从更新字段中，分类出新增、修改字段（空方法）.修改字段分类列表数据集条数 大于等于 0))  15566
        
//ModelCode: circulationCollections
        for (NewColumnDto circulationCollectionsRes_5: dataAuClassificationRes_2.getNewColumnList()){ 
      
//ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_5 = null;
    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_4=new AutoAenerateSemanticContentReqDto();
  if(reqDto!=null){
      generateSemanticInstanceReq_4.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15610
    }
if(circulationCollectionsRes_5!=null){
      generateSemanticInstanceReq_4.setReviseBehaviorName(circulationCollectionsRes_5.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15610
generateSemanticInstanceReq_4.setColumnContent(circulationCollectionsRes_5.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15610
    }
  
    /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq_4.getReviseSubjectContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空",false);
Assert.isNull(generateSemanticInstanceReq_4.getReviseBehaviorName(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空",false);
Assert.isNull(generateSemanticInstanceReq_4.getColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空",false);
      generateSemanticInstanceRes_5 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_4);
      
      
      
if((circulationCollectionsRes_5!= null&& circulationCollectionsRes_5.getOriColumnContent() == null )) {
        //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  15655
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_5 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_4=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_4.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_15656
  
    /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空",false);
      receptionServiceRes_5 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_4);
      
      
      
String string_7 = null;
    ChangeColumn changeColumn_9=new ChangeColumn();
  changeColumn_9.setIsInproperties("TRUE");//sourceId:304307_1_15657
changeColumn_9.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15657
if(reqDto!=null){
      changeColumn_9.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15657
changeColumn_9.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15657
changeColumn_9.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15657
changeColumn_9.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15657
changeColumn_9.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15657
changeColumn_9.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15657
changeColumn_9.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15657
changeColumn_9.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15657
changeColumn_9.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15657
    }
if(circulationCollectionsRes_5!=null){
      changeColumn_9.setObjectPropertyCode(circulationCollectionsRes_5.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15657
changeColumn_9.setMetaDataColumnContent(circulationCollectionsRes_5.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15657
changeColumn_9.setColumnContent(circulationCollectionsRes_5.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15657
    }
if(generateSemanticInstanceRes_5!=null){
      changeColumn_9.setObjectPropertyName(generateSemanticInstanceRes_5.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15657
    }
if(receptionServiceRes_5!=null){
      changeColumn_9.setOriColumnContent(receptionServiceRes_5.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15657
    }
  
    /*1-1-02新增底层框架服务变更字段[5]   */
    Assert.isNull(changeColumn_9.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空",false);
Assert.isNull(changeColumn_9.getEntityName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn_9.getEntityId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空",false);
Assert.isNull(changeColumn_9.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_9.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_9.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_9.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_9.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_9.getIsInproperties(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空",false);
Assert.isNull(changeColumn_9.getSubjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空",false);
Assert.isNull(changeColumn_9.getSubjectChangeType(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn_9.getObjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn_9.getObjectId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn_9.getSubjectUpdateStatus(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn_9.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_9.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空",false);
      string_7 = mChangeColumnService.addBaseChangeColumn(changeColumn_9);
      
      
      
      }
else{
       //else  15716

String string_8 = null;
    ChangeColumn changeColumn_10=new ChangeColumn();
  changeColumn_10.setIsInproperties("TRUE");//sourceId:304307_1_15717
changeColumn_10.setSubjectUpdateStatus("REVISION");//sourceId:304314_1_15717
if(reqDto!=null){
      changeColumn_10.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:304302_1_15717
changeColumn_10.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:304319_1_15717
changeColumn_10.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:304303_1_15717
changeColumn_10.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:304313_1_15717
changeColumn_10.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:304308_1_15717
changeColumn_10.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:304316_1_15717
changeColumn_10.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:304315_1_15717
changeColumn_10.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304318_1_15717
changeColumn_10.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304306_1_15717
    }
if(circulationCollectionsRes_5!=null){
      changeColumn_10.setObjectPropertyCode(circulationCollectionsRes_5.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304300_1_15717
changeColumn_10.setMetaDataColumnContent(circulationCollectionsRes_5.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304301_1_15717
changeColumn_10.setOriColumnContent(circulationCollectionsRes_5.getOriColumnContent());//SimpleFieldAssign//sourceId:304311_1_15717
changeColumn_10.setColumnContent(circulationCollectionsRes_5.getColumnContent());//SimpleFieldAssign//sourceId:304312_1_15717
    }
if(generateSemanticInstanceRes_5!=null){
      changeColumn_10.setObjectPropertyName(generateSemanticInstanceRes_5.getObjectName());//SimpleFieldAssign//sourceId:304310_1_15717
    }

    /*1-1-02新增底层框架服务变更字段[5]   */
    Assert.isNull(changeColumn_10.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表类型编码不能为空",false);
Assert.isNull(changeColumn_10.getEntityName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(changeColumn_10.getEntityId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-内容表主键ID不能为空",false);
Assert.isNull(changeColumn_10.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_10.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_10.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_10.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_10.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_10.getIsInproperties(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否内部属性不能为空",false);
Assert.isNull(changeColumn_10.getSubjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体类型编码不能为空",false);
Assert.isNull(changeColumn_10.getSubjectChangeType(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体变更日志类型不能为空",false);
Assert.isNull(changeColumn_10.getObjectTypeCode(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象类型编码不能为空",false);
Assert.isNull(changeColumn_10.getObjectId(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-归属对象内容ID不能为空",false);
Assert.isNull(changeColumn_10.getSubjectUpdateStatus(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体批次下更新状态不能为空",false);
Assert.isNull(changeColumn_10.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_10.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02新增底层框架服务变更字段-主体生命周期不能为空",false);
      string_8 = mChangeColumnService.addBaseChangeColumn(changeColumn_10);
      
      
      
    }
//ModelCode: circulationEnd
        }
      
      }
if((dataAuClassificationRes_2!= null&&  dataAuClassificationRes_2.getModifyColumnList() !=null && dataAuClassificationRes_2.getModifyColumnList().size()>0&&dataAuClassificationRes_2!= null&&  dataAuClassificationRes_2.getNewColumnList() !=null && dataAuClassificationRes_2.getNewColumnList().size()>=0)) {
        //if((从更新字段中，分类出新增、修改字段（空方法）.修改字段分类列表数据集条数 大于 0 and 从更新字段中，分类出新增、修改字段（空方法）.新增字段分类列表数据集条数 大于等于 0))  15570
        
//ModelCode: circulationCollections
        for (ModifyColumnDto circulationCollectionsRes_6: dataAuClassificationRes_2.getModifyColumnList()){ 
      
//ModelCode: generateSemanticInstance
        AutoAenerateSemanticContentRespDto generateSemanticInstanceRes_6 = null;
    AutoAenerateSemanticContentReqDto generateSemanticInstanceReq_5=new AutoAenerateSemanticContentReqDto();
  if(reqDto!=null){
      generateSemanticInstanceReq_5.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:304355_1_15618
    }
if(circulationCollectionsRes_6!=null){
      generateSemanticInstanceReq_5.setReviseBehaviorName(circulationCollectionsRes_6.getObjectPropertyName());//SimpleFieldAssign//sourceId:304354_1_15618
generateSemanticInstanceReq_5.setColumnContent(circulationCollectionsRes_6.getColumnContent());//SimpleFieldAssign//sourceId:304356_1_15618
    }
  
    /*M1-生成变更字段语义故事内容[3975]  解析语义模板，生成模板实例 */
    Assert.isNull(generateSemanticInstanceReq_5.getReviseSubjectContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订主体内容不能为空",false);
Assert.isNull(generateSemanticInstanceReq_5.getReviseBehaviorName(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-修订行为名称不能为空",false);
Assert.isNull(generateSemanticInstanceReq_5.getColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-生成变更字段语义故事内容-变更字段中文内容不能为空",false);
      generateSemanticInstanceRes_6 = nbChangeColumn.autoAenerateSemanticContent(generateSemanticInstanceReq_5);
      
      
      
if((circulationCollectionsRes_6!= null&& circulationCollectionsRes_6.getOriColumnContent() == null )) {
        //if(M1-1-02执行变更字段【循环开始】.原始字段中文内容 值等于空 )  16196

//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_6 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_5=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_5.setOriColumnContent("无");//CUSTOM_CONVENTION//sourceId:304762_1_16200

    /*M1-约定原始字段值[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-M1-约定原始字段值-原始字段中文内容不能为空",false);
      receptionServiceRes_6 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_5);



boolean bOOLEAN_3 ;
    ChangeColumn changeColumn_11=new ChangeColumn();
  changeColumn_11.setIsArchive("FALSE");//sourceId:304329_1_16197
changeColumn_11.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_16197
if(changeColumn_11!=null && changeColumn_11.getSubjectLifeCycle()!=null &&  changeColumn_11.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
            changeColumn_11.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
          }//sourceId:304326_1_16197
if(changeColumn_11!=null && changeColumn_11.getSubjectLifeCycle()!=null && changeColumn_11.getSubjectLifeCycle().equals("CURRENTLY_VALID")){
             changeColumn_11.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
            }//sourceId:304328_1_16197
if(circulationCollectionsRes_6!=null){
      changeColumn_11.setChangeColumnId(circulationCollectionsRes_6.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_16197
changeColumn_11.setObjectPropertyCode(circulationCollectionsRes_6.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_16197
changeColumn_11.setMetaDataColumnContent(circulationCollectionsRes_6.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_16197
changeColumn_11.setColumnContent(circulationCollectionsRes_6.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_16197
    }
if(generateSemanticInstanceRes_6!=null){
      changeColumn_11.setObjectPropertyName(generateSemanticInstanceRes_6.getObjectName());//SimpleFieldAssign//sourceId:304332_1_16197
    }
if(receptionServiceRes_6!=null){
      changeColumn_11.setOriColumnContent(receptionServiceRes_6.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_16197
    }
if(reqDto!=null){
      changeColumn_11.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_16197
changeColumn_11.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_16197
    }

    /*1-1-02修改底层变更字段[6]   */
    Assert.isNull(changeColumn_11.getChangeColumnId(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空",false);
Assert.isNull(changeColumn_11.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_11.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_11.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_11.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_11.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_11.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_11.getIsArchive(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空",false);
Assert.isNull(changeColumn_11.getArchivngType(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空",false);
Assert.isNull(changeColumn_11.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空",false);
      bOOLEAN_3 = mChangeColumnService.updateBaseChangeCol(changeColumn_11);



      }
else{
       //else  16198

boolean bOOLEAN_4 ;
    ChangeColumn changeColumn_12=new ChangeColumn();
  changeColumn_12.setIsArchive("FALSE");//sourceId:304329_1_16199
changeColumn_12.setArchivngType("NOT_ARCHIVE");//sourceId:304330_1_16199
if(changeColumn_12!=null && changeColumn_12.getSubjectLifeCycle()!=null &&  changeColumn_12.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
            changeColumn_12.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
          }//sourceId:304326_1_16199
if(changeColumn_12!=null && changeColumn_12.getSubjectLifeCycle()!=null && changeColumn_12.getSubjectLifeCycle().equals("CURRENTLY_VALID")){
             changeColumn_12.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
            }//sourceId:304328_1_16199
if(circulationCollectionsRes_6!=null){
      changeColumn_12.setChangeColumnId(circulationCollectionsRes_6.getChangeColumnId());//SimpleFieldAssign//sourceId:304320_1_16199
changeColumn_12.setObjectPropertyCode(circulationCollectionsRes_6.getObjectPropertyCode());//SimpleFieldAssign//sourceId:304335_1_16199
changeColumn_12.setMetaDataColumnContent(circulationCollectionsRes_6.getMetaDataColumnContent());//SimpleFieldAssign//sourceId:304321_1_16199
changeColumn_12.setOriColumnContent(circulationCollectionsRes_6.getOriColumnContent());//SimpleFieldAssign//sourceId:304333_1_16199
changeColumn_12.setColumnContent(circulationCollectionsRes_6.getColumnContent());//SimpleFieldAssign//sourceId:304334_1_16199
    }
if(generateSemanticInstanceRes_6!=null){
      changeColumn_12.setObjectPropertyName(generateSemanticInstanceRes_6.getObjectName());//SimpleFieldAssign//sourceId:304332_1_16199
    }
if(reqDto!=null){
      changeColumn_12.setIsEditing(reqDto.getIsEditing());//SimpleFieldAssign//sourceId:304331_1_16199
changeColumn_12.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:304324_1_16199
    }
  
    /*1-1-02修改底层变更字段[6]   */
    Assert.isNull(changeColumn_12.getChangeColumnId(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段记录ID不能为空",false);
Assert.isNull(changeColumn_12.getObjectPropertyCode(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段英文名不能为空",false);
Assert.isNull(changeColumn_12.getObjectPropertyName(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段行为日志名称不能为空",false);
Assert.isNull(changeColumn_12.getMetaDataColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段内容不能为空",false);
Assert.isNull(changeColumn_12.getOriColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-原始字段中文内容不能为空",false);
Assert.isNull(changeColumn_12.getColumnContent(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-变更字段中文内容不能为空",false);
Assert.isNull(changeColumn_12.getIsEditing(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否未来不能为空",false);
Assert.isNull(changeColumn_12.getIsArchive(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-是否存档不能为空",false);
Assert.isNull(changeColumn_12.getArchivngType(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-存档类型不能为空",false);
Assert.isNull(changeColumn_12.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-1-1-02修改底层变更字段-主体生命周期不能为空",false);
      bOOLEAN_4 = mChangeColumnService.updateBaseChangeCol(changeColumn_12);
      
      
      
    }
//ModelCode: circulationEnd
        }
      
      }
    }
if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))) {
        //if(D1-1执行修订底层变更字段(公共).主体生命周期 等于 当前有效)  15587
        
BatchWriteBackBaseChangeColComRespDto batchWriteBackBaseChangeColComRespDto = null;
    BatchWriteBackBaseChangeColComReqDto batchWriteBackBaseChangeColComReqDto=new BatchWriteBackBaseChangeColComReqDto();
  if(reqDto!=null){
      batchWriteBackBaseChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:306207_1_15671
batchWriteBackBaseChangeColComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:306208_1_15671
batchWriteBackBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:306209_1_15671
batchWriteBackBaseChangeColComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:306210_1_15671
batchWriteBackBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:306211_1_15671
batchWriteBackBaseChangeColComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:306212_1_15671
    }
  
    /*D1批量回写底层变更字段(公共)[4382]   */
    Assert.isNull(batchWriteBackBaseChangeColComReqDto.getTableTypeCode(),"D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-内容表类型编码不能为空",false);
Assert.isNull(batchWriteBackBaseChangeColComReqDto.getEntityId(),"D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-内容表主键ID不能为空",false);
Assert.isNull(batchWriteBackBaseChangeColComReqDto.getObjectTypeCode(),"D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-归属对象类型编码不能为空",false);
Assert.isNull(batchWriteBackBaseChangeColComReqDto.getObjectId(),"D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-归属对象内容ID不能为空",false);
Assert.isNull(batchWriteBackBaseChangeColComReqDto.getSubjectLifeCycle(),"D1-1执行修订底层变更字段(公共)-D1批量回写底层变更字段(公共)-主体生命周期不能为空",false);
      batchWriteBackBaseChangeColComRespDto = batchWriteBackBaseChangeColCom(batchWriteBackBaseChangeColComReqDto);
      
      
      
      }
    }
//processBranchName:正常结束 ,processBranchId:15592
        
ImplementReviseBaseChangeColComRespDto retData = new ImplementReviseBaseChangeColComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-1判断生命周期底层变更字段[4344]
   * gen by moon at 9/2/2022, 5:45:26 PM
   */
  @Trace(operationName = "D1-1判断生命周期底层变更字段")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeSubjectLifeCycleBaseChangeColRespDto judgeSubjectLifeCycleBaseChangeCol(JudgeSubjectLifeCycleBaseChangeColReqDto reqDto){
    
      
      if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("EDITING"))) {
        //if(D1-1判断生命周期底层变更字段.主体生命周期 等于 正在编辑)  15396
        
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:288137_1_15400
receptionServiceReq.setIsEditing("TRUE");//sourceId:288142_1_15400
receptionServiceReq.setSubjectLifeCycle("EDITING");//sourceId:288129_1_15400
if(reqDto!=null){
      receptionServiceReq.setBatchId(reqDto.getBatchId());//sourceId:288127_1_15400
    }
  
    /*M1-生命周期正在编辑[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getIsEditing(),"D1-1判断生命周期底层变更字段-M1-生命周期正在编辑-是否未来不能为空",false);
Assert.isNull(receptionServiceReq.getSubjectLifeCycle(),"D1-1判断生命周期底层变更字段-M1-生命周期正在编辑-主体生命周期不能为空",false);
      receptionServiceRes = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq);
      
      
      
ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto = null;
    ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto=new ImplementReviseBaseChangeColComReqDto();
  if(receptionServiceRes!=null){
      implementReviseBaseChangeColComReqDto.setBatchId(receptionServiceRes.getBatchId());//sourceId:288002_1_15398
implementReviseBaseChangeColComReqDto.setBatchEndTime(receptionServiceRes.getBatchEndTime());//sourceId:287998_1_15398
implementReviseBaseChangeColComReqDto.setIsEditing(receptionServiceRes.getIsEditing());//sourceId:287999_1_15398
implementReviseBaseChangeColComReqDto.setSubjectLifeCycle(receptionServiceRes.getSubjectLifeCycle());//sourceId:288000_1_15398
    }
if(reqDto!=null){
      implementReviseBaseChangeColComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:287990_1_15398
implementReviseBaseChangeColComReqDto.setEntityName(reqDto.getEntityName());//sourceId:288001_1_15398
implementReviseBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//sourceId:287991_1_15398
implementReviseBaseChangeColComReqDto.setSubjectTypeCode(reqDto.getSubjectTypeCode());//sourceId:287993_1_15398
implementReviseBaseChangeColComReqDto.setSubjectChangeType(reqDto.getSubjectChangeType());//sourceId:287994_1_15398
implementReviseBaseChangeColComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:287995_1_15398
implementReviseBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//sourceId:287996_1_15398
implementReviseBaseChangeColComReqDto.setChangeColumnList(reqDto.getChangeColumnList());//sourceId:287992_1_15398
implementReviseBaseChangeColComReqDto.setReviseSubjectContent(reqDto.getReviseSubjectContent());//sourceId:288003_1_15398
    }
  
    /*D1-1执行修订底层变更字段(正在编辑)[272]   */
    Assert.isNull(implementReviseBaseChangeColComReqDto.getIsEditing(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-是否未来不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectLifeCycle(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-主体生命周期不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getTableTypeCode(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-内容表类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getEntityName(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getEntityId(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-内容表主键ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectTypeCode(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-主体类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectChangeType(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-主体变更日志类型不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getObjectTypeCode(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-归属对象类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getObjectId(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-归属对象内容ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getReviseSubjectContent(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(正在编辑)-修订主体内容不能为空",false);
      implementReviseBaseChangeColComRespDto = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto);
      
      
      
//processBranchName:正常结束 ,processBranchId:15402
        
      }
else if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID"))){
       //elseif(D1-1判断生命周期底层变更字段.主体生命周期 等于 当前有效)  15397
      
//ModelCode: receptionService
        QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
    QueryReceiveFieldDetailReqDto receptionServiceReq_1=new QueryReceiveFieldDetailReqDto();
  receptionServiceReq_1.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:288252_1_15401
receptionServiceReq_1.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:288253_1_15401
receptionServiceReq_1.setIsEditing("FALSE");//sourceId:288249_1_15401
receptionServiceReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:288250_1_15401
if(reqDto!=null){
      receptionServiceReq_1.setBatchId(reqDto.getBatchId());//sourceId:288251_1_15401
    }
  
    /*M1-生命周期当前有效[3715]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getIsEditing(),"D1-1判断生命周期底层变更字段-M1-生命周期当前有效-是否未来不能为空",false);
Assert.isNull(receptionServiceReq_1.getSubjectLifeCycle(),"D1-1判断生命周期底层变更字段-M1-生命周期当前有效-主体生命周期不能为空",false);
      receptionServiceRes_2 = nbChangeColumn.queryReceiveFieldDetail(receptionServiceReq_1);
      
      
      
ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto_1 = null;
    ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto_1=new ImplementReviseBaseChangeColComReqDto();
  if(receptionServiceRes_2!=null){
      implementReviseBaseChangeColComReqDto_1.setBatchId(receptionServiceRes_2.getBatchId());//sourceId:288016_1_15399
implementReviseBaseChangeColComReqDto_1.setBatchStartTime(receptionServiceRes_2.getBatchStartTime());//sourceId:288011_1_15399
implementReviseBaseChangeColComReqDto_1.setBatchEndTime(receptionServiceRes_2.getBatchEndTime());//sourceId:288012_1_15399
implementReviseBaseChangeColComReqDto_1.setIsEditing(receptionServiceRes_2.getIsEditing());//sourceId:288013_1_15399
implementReviseBaseChangeColComReqDto_1.setSubjectLifeCycle(receptionServiceRes_2.getSubjectLifeCycle());//sourceId:288014_1_15399
    }
if(reqDto!=null){
      implementReviseBaseChangeColComReqDto_1.setTableTypeCode(reqDto.getTableTypeCode());//sourceId:288004_1_15399
implementReviseBaseChangeColComReqDto_1.setEntityName(reqDto.getEntityName());//sourceId:288015_1_15399
implementReviseBaseChangeColComReqDto_1.setEntityId(reqDto.getEntityId());//sourceId:288005_1_15399
implementReviseBaseChangeColComReqDto_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//sourceId:288007_1_15399
implementReviseBaseChangeColComReqDto_1.setSubjectChangeType(reqDto.getSubjectChangeType());//sourceId:288008_1_15399
implementReviseBaseChangeColComReqDto_1.setObjectTypeCode(reqDto.getObjectTypeCode());//sourceId:288009_1_15399
implementReviseBaseChangeColComReqDto_1.setObjectId(reqDto.getObjectId());//sourceId:288010_1_15399
implementReviseBaseChangeColComReqDto_1.setChangeColumnList(reqDto.getChangeColumnList());//sourceId:288006_1_15399
implementReviseBaseChangeColComReqDto_1.setReviseSubjectContent(reqDto.getReviseSubjectContent());//sourceId:288017_1_15399
    }
  
    /*D1-1执行修订底层变更字段(当前有效)[272]   */
    Assert.isNull(implementReviseBaseChangeColComReqDto_1.getIsEditing(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-是否未来不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectLifeCycle(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-主体生命周期不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getTableTypeCode(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-内容表类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getEntityName(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getEntityId(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-内容表主键ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectTypeCode(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-主体类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectChangeType(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-主体变更日志类型不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getObjectTypeCode(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-归属对象类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getObjectId(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-归属对象内容ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getReviseSubjectContent(),"D1-1判断生命周期底层变更字段-D1-1执行修订底层变更字段(当前有效)-修订主体内容不能为空",false);
      implementReviseBaseChangeColComRespDto_1 = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto_1);
      
      
      
//processBranchName:正常结束 ,processBranchId:15403
        
    }
JudgeSubjectLifeCycleBaseChangeColRespDto retData = new JudgeSubjectLifeCycleBaseChangeColRespDto();
  
  

  
  
return retData;
  }
/**
   * D1-判断重置修订元素[4343]
   * gen by moon at 10/2/2022, 6:30:40 AM
   */
  @Trace(operationName = "D1-判断重置修订元素")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeReviseElementRespDto judgeReviseElement(JudgeReviseElementReqDto reqDto){
    
      
      List<ChangeColumn> listChangeColumn_1 =new ArrayList<>();
//步骤0: 1-1-02查询底层变更字段列表 - queryBaseChangeColList
     List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:287679_1
queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:287680_1
queryBaseChangeColListReq.setSubjectLifeCycle("EDITING");//sourceId:301459_1
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:287681_1
if(reqDto!=null){
      queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:287677_1
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:287678_1
    }
  
    /*1-1-02查询底层变更字段列表[8]   */
    Assert.isNull(queryBaseChangeColListReq.getTableTypeCode(),"D1-判断重置修订元素-1-1-02查询底层变更字段列表-内容表类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getEntityId(),"D1-判断重置修订元素-1-1-02查询底层变更字段列表-内容表主键ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getIsInproperties(),"D1-判断重置修订元素-1-1-02查询底层变更字段列表-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(),"D1-判断重置修订元素-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1-判断重置修订元素-1-1-02查询底层变更字段列表-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1-判断重置修订元素-1-1-02查询底层变更字段列表-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq);
      
      
      listChangeColumn_1 = listChangeColumn;
    
JudgeReviseElementRespDto retData = new JudgeReviseElementRespDto();
  retData.setReviseElementList(listChangeColumn_1.stream().map(item->item.getChangeColumnId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:301460_1
  

  
  
return retData;
  }
/**
   * D1-1判断生命周期底层变更字段(公共)[4344]
   * gen by moon at 10/2/2022, 6:30:58 AM
   */
  @Trace(operationName = "D1-1判断生命周期底层变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeSubjectLifeCycleBaseChangeColComRespDto judgeSubjectLifeCycleBaseChangeColCom(JudgeSubjectLifeCycleBaseChangeColComReqDto reqDto){
    
      
      if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("EDITING")&&reqDto!= null&& reqDto.getBatchId() != null )) {
        //if((D1-1判断生命周期底层变更字段(公共).主体生命周期 等于 正在编辑 and D1-1判断生命周期底层变更字段(公共).批次ID 值不等于空 ))  15396
        
ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto = null;
    ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto=new ImplementReviseBaseChangeColComReqDto();
  implementReviseBaseChangeColComReqDto.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:302192_1_15398
implementReviseBaseChangeColComReqDto.setIsEditing("TRUE");//sourceId:302193_1_15398
implementReviseBaseChangeColComReqDto.setSubjectLifeCycle("EDITING");//sourceId:302194_1_15398
if(reqDto!=null){
      implementReviseBaseChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:302191_1_15398
implementReviseBaseChangeColComReqDto.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:302195_1_15398
implementReviseBaseChangeColComReqDto.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:302196_1_15398
implementReviseBaseChangeColComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:302197_1_15398
implementReviseBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:302198_1_15398
implementReviseBaseChangeColComReqDto.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:302199_1_15398
implementReviseBaseChangeColComReqDto.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:302200_1_15398
implementReviseBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:302201_1_15398
implementReviseBaseChangeColComReqDto.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:302202_1_15398
implementReviseBaseChangeColComReqDto.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:303944_1_15398
    }
  
    /*D1-1执行修订底层变更字段(批次下正在编辑)[272]   */
    Assert.isNull(implementReviseBaseChangeColComReqDto.getBatchId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-批次ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getBatchEndTime(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-批次结束时间不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getIsEditing(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-是否未来不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectLifeCycle(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-主体生命周期不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-主体类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getSubjectChangeType(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-主体变更日志类型不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getTableTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-内容表类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getEntityId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-内容表主键ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getEntityName(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getObjectTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-归属对象类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getObjectId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-归属对象内容ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto.getReviseSubjectContent(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下正在编辑)-修订主体内容不能为空",false);
      implementReviseBaseChangeColComRespDto = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto);
      
      
      
//processBranchName:正常结束 ,processBranchId:15402
        
      }
else if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID")&&reqDto!= null&& reqDto.getBatchId() != null )){
       //elseif((D1-1判断生命周期底层变更字段(公共).主体生命周期 等于 当前有效 and D1-1判断生命周期底层变更字段(公共).批次ID 值不等于空 ))  15397
      
ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto_1 = null;
    ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto_1=new ImplementReviseBaseChangeColComReqDto();
  implementReviseBaseChangeColComReqDto_1.setBatchStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:302204_1_15399
implementReviseBaseChangeColComReqDto_1.setBatchEndTime(CommonFunctionHelper.getFutureTime());//FUTURE_CURRENT_TIME//sourceId:302205_1_15399
implementReviseBaseChangeColComReqDto_1.setIsEditing("FALSE");//sourceId:302206_1_15399
implementReviseBaseChangeColComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:302207_1_15399
if(reqDto!=null){
      implementReviseBaseChangeColComReqDto_1.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:302203_1_15399
implementReviseBaseChangeColComReqDto_1.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:302208_1_15399
implementReviseBaseChangeColComReqDto_1.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:302209_1_15399
implementReviseBaseChangeColComReqDto_1.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:302210_1_15399
implementReviseBaseChangeColComReqDto_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:302211_1_15399
implementReviseBaseChangeColComReqDto_1.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:302212_1_15399
implementReviseBaseChangeColComReqDto_1.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:302213_1_15399
implementReviseBaseChangeColComReqDto_1.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:302214_1_15399
implementReviseBaseChangeColComReqDto_1.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:302215_1_15399
implementReviseBaseChangeColComReqDto_1.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:303945_1_15399
    }
  
    /*D1-1执行修订底层变更字段(批次下当前有效)[272]   */
    Assert.isNull(implementReviseBaseChangeColComReqDto_1.getBatchId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-批次ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getBatchStartTime(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-批次开始时间不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getBatchEndTime(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-批次结束时间不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getIsEditing(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-是否未来不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectLifeCycle(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-主体生命周期不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-主体类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getSubjectChangeType(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-主体变更日志类型不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getTableTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-内容表类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getEntityId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-内容表主键ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getEntityName(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getObjectTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-归属对象类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getObjectId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-归属对象内容ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_1.getReviseSubjectContent(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(批次下当前有效)-修订主体内容不能为空",false);
      implementReviseBaseChangeColComRespDto_1 = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto_1);
      
      
      
//processBranchName:正常结束 ,processBranchId:15403
        
    }
else if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("EDITING")&&reqDto!= null&& reqDto.getBatchId() == null )){
       //elseif((D1-1判断生命周期底层变更字段(公共).主体生命周期 等于 正在编辑 and D1-1判断生命周期底层变更字段(公共).批次ID 值等于空 ))  15538
      
ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto_2 = null;
    ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto_2=new ImplementReviseBaseChangeColComReqDto();
  implementReviseBaseChangeColComReqDto_2.setIsEditing("TRUE");//sourceId:302216_1_15540
implementReviseBaseChangeColComReqDto_2.setSubjectLifeCycle("EDITING");//sourceId:302217_1_15540
if(reqDto!=null){
      implementReviseBaseChangeColComReqDto_2.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:302218_1_15540
implementReviseBaseChangeColComReqDto_2.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:302219_1_15540
implementReviseBaseChangeColComReqDto_2.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:302220_1_15540
implementReviseBaseChangeColComReqDto_2.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:302221_1_15540
implementReviseBaseChangeColComReqDto_2.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:302222_1_15540
implementReviseBaseChangeColComReqDto_2.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:302223_1_15540
implementReviseBaseChangeColComReqDto_2.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:302224_1_15540
implementReviseBaseChangeColComReqDto_2.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:302225_1_15540
implementReviseBaseChangeColComReqDto_2.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:303946_1_15540
    }
  
    /*D1-1执行修订底层变更字段(无批次的正在编辑)[272]   */
    Assert.isNull(implementReviseBaseChangeColComReqDto_2.getIsEditing(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-是否未来不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_2.getSubjectLifeCycle(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-主体生命周期不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_2.getSubjectTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-主体类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_2.getSubjectChangeType(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-主体变更日志类型不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_2.getTableTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-内容表类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_2.getEntityId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-内容表主键ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_2.getEntityName(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_2.getObjectTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-归属对象类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_2.getObjectId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-归属对象内容ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_2.getReviseSubjectContent(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的正在编辑)-修订主体内容不能为空",false);
      implementReviseBaseChangeColComRespDto_2 = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto_2);
      
      
      
//processBranchName:正常结束 ,processBranchId:15541
        
    }
else if((reqDto!= null&&  reqDto.getSubjectLifeCycle() !=null && reqDto.getSubjectLifeCycle().equals("CURRENTLY_VALID")&&reqDto!= null&& reqDto.getBatchId() == null )){
       //elseif((D1-1判断生命周期底层变更字段(公共).主体生命周期 等于 当前有效 and D1-1判断生命周期底层变更字段(公共).批次ID 值等于空 ))  15539
      
ImplementReviseBaseChangeColComRespDto implementReviseBaseChangeColComRespDto_3 = null;
    ImplementReviseBaseChangeColComReqDto implementReviseBaseChangeColComReqDto_3=new ImplementReviseBaseChangeColComReqDto();
  implementReviseBaseChangeColComReqDto_3.setIsEditing("FALSE");//sourceId:302229_1_15542
implementReviseBaseChangeColComReqDto_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:302230_1_15542
if(reqDto!=null){
      implementReviseBaseChangeColComReqDto_3.setSubjectTypeCode(reqDto.getSubjectTypeCode());//SimpleFieldAssign//sourceId:302231_1_15542
implementReviseBaseChangeColComReqDto_3.setSubjectChangeType(reqDto.getSubjectChangeType());//SimpleFieldAssign//sourceId:302232_1_15542
implementReviseBaseChangeColComReqDto_3.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:302233_1_15542
implementReviseBaseChangeColComReqDto_3.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:302234_1_15542
implementReviseBaseChangeColComReqDto_3.setEntityName(reqDto.getEntityName());//SimpleFieldAssign//sourceId:302235_1_15542
implementReviseBaseChangeColComReqDto_3.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:302236_1_15542
implementReviseBaseChangeColComReqDto_3.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:302237_1_15542
implementReviseBaseChangeColComReqDto_3.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:302238_1_15542
implementReviseBaseChangeColComReqDto_3.setReviseSubjectContent(reqDto.getReviseSubjectContent());//SimpleFieldAssign//sourceId:303947_1_15542
    }
  
    /*D1-1执行修订底层变更字段(无批次的当前有效)[272]   */
    Assert.isNull(implementReviseBaseChangeColComReqDto_3.getIsEditing(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-是否未来不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_3.getSubjectLifeCycle(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-主体生命周期不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_3.getSubjectTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-主体类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_3.getSubjectChangeType(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-主体变更日志类型不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_3.getTableTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-内容表类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_3.getEntityId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-内容表主键ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_3.getEntityName(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_3.getObjectTypeCode(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-归属对象类型编码不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_3.getObjectId(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-归属对象内容ID不能为空",false);
Assert.isNull(implementReviseBaseChangeColComReqDto_3.getReviseSubjectContent(),"D1-1判断生命周期底层变更字段(公共)-D1-1执行修订底层变更字段(无批次的当前有效)-修订主体内容不能为空",false);
      implementReviseBaseChangeColComRespDto_3 = implementReviseBaseChangeColCom(implementReviseBaseChangeColComReqDto_3);
      
      
      
//processBranchName:正常结束 ,processBranchId:15543
        
    }
JudgeSubjectLifeCycleBaseChangeColComRespDto retData = new JudgeSubjectLifeCycleBaseChangeColComRespDto();
  
  

  
  
return retData;
  }
/**
   * D1修订组织批次下内容[4355]
   * gen by moon at 10/2/2022, 6:31:16 AM
   */
  @Trace(operationName = "D1修订组织批次下内容")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ReviseOrgAtchContentRespDto reviseOrgAtchContent(ReviseOrgAtchContentReqDto reqDto){
    
      
      //步骤0: D1-3查询个人就职记录信息详情（公共） - queryInductionRecordInfoDetailCom
     QueryInductionRecordInfoDetailComRespDto queryInductionRecordInfoDetailComRespDto = null;
    QueryInductionRecordInfoDetailComReqDto queryInductionRecordInfoDetailComReqDto=new QueryInductionRecordInfoDetailComReqDto();
  queryInductionRecordInfoDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:301556_1
if(reqDto!=null){
      queryInductionRecordInfoDetailComReqDto.setInductionRecordId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:301546_1
    }
  
    /*D1-3查询个人就职记录信息详情（公共）[715]   */
    Assert.isNull(queryInductionRecordInfoDetailComReqDto.getInductionRecordId(),"D1修订组织批次下内容-D1-3查询个人就职记录信息详情（公共）-就职记录ID不能为空",false);
Assert.isNull(queryInductionRecordInfoDetailComReqDto.getSpaceId(),"D1修订组织批次下内容-D1-3查询个人就职记录信息详情（公共）-创建于空间ID不能为空",false);
      queryInductionRecordInfoDetailComRespDto = inductionRecordService.queryInductionRecordInfoDetailCom(queryInductionRecordInfoDetailComReqDto);
      
      
      
    
//步骤1: 1-3-13修改就职记录 - updateInductionRecord
     boolean bOOLEAN ;
    InductionRecord inductionRecord=new InductionRecord();
  inductionRecord.setIsUpdate("TRUE");//sourceId:301612_1
inductionRecord.setUpdateStatus("REVISION");//sourceId:301613_1
inductionRecord.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:301614_1
inductionRecord.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:301615_1
if(reqDto!=null){
      inductionRecord.setInductionRecordId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:301611_1
    }
  
    /*1-3-13修改就职记录（修改本次修订）[163]   */
    Assert.isNull(inductionRecord.getInductionRecordId(),"D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-就职记录ID不能为空",false);
Assert.isNull(inductionRecord.getIsUpdate(),"D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-批次下是否更新不能为空",false);
Assert.isNull(inductionRecord.getUpdateStatus(),"D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-批次下更新状态不能为空",false);
Assert.isNull(inductionRecord.getOperationInductionId(),"D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-操作人就职记录ID不能为空",false);
Assert.isNull(inductionRecord.getOperateTime(),"D1修订组织批次下内容-1-3-13修改就职记录（修改本次修订）-操作时间不能为空",false);
      bOOLEAN = mInductionRecordService.updateInductionRecord(inductionRecord);
      
      
      
    
//步骤2: D1-1判断生命周期底层变更字段(公共) - judgeSubjectLifeCycleBaseChangeColCom
     JudgeSubjectLifeCycleBaseChangeColComRespDto judgeSubjectLifeCycleBaseChangeColComRespDto = null;
    if(queryInductionRecordInfoDetailComRespDto !=null){
          JudgeSubjectLifeCycleBaseChangeColComReqDto judgeSubjectLifeCycleBaseChangeColComReqDto=new JudgeSubjectLifeCycleBaseChangeColComReqDto();
  judgeSubjectLifeCycleBaseChangeColComReqDto.setSubjectLifeCycle("EDITING");//sourceId:301559_1
judgeSubjectLifeCycleBaseChangeColComReqDto.setSubjectTypeCode("ORG_LOG_NAV");//sourceId:301563_1
judgeSubjectLifeCycleBaseChangeColComReqDto.setSubjectChangeType("REVISE_REPORT_TO");//CUSTOM_CONVENTION//sourceId:301564_1
judgeSubjectLifeCycleBaseChangeColComReqDto.setTableTypeCode("OMS_ORG_INDUCTION_RECORD");//sourceId:301565_1
judgeSubjectLifeCycleBaseChangeColComReqDto.setEntityName("inductionRecordId");//CUSTOM_CONVENTION//sourceId:301566_1
judgeSubjectLifeCycleBaseChangeColComReqDto.setObjectTypeCode("OMS_ORG_ORGANIZATION");//sourceId:301567_1
if(reqDto!=null){
      judgeSubjectLifeCycleBaseChangeColComReqDto.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:301558_1
judgeSubjectLifeCycleBaseChangeColComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:301560_1
judgeSubjectLifeCycleBaseChangeColComReqDto.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:301561_1
judgeSubjectLifeCycleBaseChangeColComReqDto.setChangeColumnList(reqDto.getChangeColumnList().stream().map(item -> BeanUtil.toBean(item, ChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:301568_1
    }
if(queryInductionRecordInfoDetailComRespDto!=null){
      judgeSubjectLifeCycleBaseChangeColComReqDto.setReviseSubjectContent(queryInductionRecordInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:301562_1
    }
  
    /*D1-1判断生命周期底层变更字段(公共)[4344]   */
    Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getBatchId(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-批次ID不能为空",false);
Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getSubjectLifeCycle(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-主体生命周期不能为空",false);
Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getSubjectTypeCode(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-主体类型编码不能为空",false);
Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getSubjectChangeType(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-主体变更日志类型不能为空",false);
Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getTableTypeCode(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-内容表类型编码不能为空",false);
Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getEntityId(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-内容表主键ID不能为空",false);
Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getEntityName(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-内容表主键行为日志英文名称不能为空",false);
Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getObjectTypeCode(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-归属对象类型编码不能为空",false);
Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getObjectId(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-归属对象内容ID不能为空",false);
Assert.isNull(judgeSubjectLifeCycleBaseChangeColComReqDto.getReviseSubjectContent(),"D1修订组织批次下内容-D1-1判断生命周期底层变更字段(公共)-修订主体内容不能为空",false);
      judgeSubjectLifeCycleBaseChangeColComRespDto = judgeSubjectLifeCycleBaseChangeColCom(judgeSubjectLifeCycleBaseChangeColComReqDto);
      
      
      
           }
    
ReviseOrgAtchContentRespDto retData = new ReviseOrgAtchContentRespDto();
  
  

  
  
return retData;
  }
/**
   * D1批量回写底层变更字段(公共)[4382]
   * gen by moon at 9/20/2023, 11:29:12 PM
   */
  @Trace(operationName = "D1批量回写底层变更字段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public BatchWriteBackBaseChangeColComRespDto batchWriteBackBaseChangeColCom(BatchWriteBackBaseChangeColComReqDto reqDto){
    
      
      //virtualUsage 1-1-02查询底层变更字段列表  15658
      List<ChangeColumn> listChangeColumn =new ArrayList<>();
    QueryBaseChangeColListReq queryBaseChangeColListReq=new QueryBaseChangeColListReq();
  queryBaseChangeColListReq.setIsInproperties("TRUE");//sourceId:305680_1_15658
queryBaseChangeColListReq.setSubjectUpdateStatus("REVISION");//sourceId:305682_1_15658
queryBaseChangeColListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:305675_1_15658
if(reqDto!=null){
      queryBaseChangeColListReq.setBatchId(reqDto.getBatchId());//SimpleFieldAssign//sourceId:305674_1_15658
queryBaseChangeColListReq.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:305672_1_15658
queryBaseChangeColListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:305673_1_15658
queryBaseChangeColListReq.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:305694_1_15658
queryBaseChangeColListReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:305695_1_15658
queryBaseChangeColListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:305678_1_15658
    }
  
    /*1-1-02查询底层变更字段列表[8]   */
    Assert.isNull(queryBaseChangeColListReq.getObjectTypeCode(),"D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-归属对象类型编码不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getObjectId(),"D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-归属对象内容ID不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getIsInproperties(),"D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-是否内部属性不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectUpdateStatus(),"D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-主体批次下更新状态不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSubjectLifeCycle(),"D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-主体生命周期不能为空",false);
Assert.isNull(queryBaseChangeColListReq.getSpaceId(),"D1批量回写底层变更字段(公共)-1-1-02查询底层变更字段列表-创建于空间ID不能为空",false);
      listChangeColumn = mChangeColumnService.queryBaseChangeColList(queryBaseChangeColListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
//virtualUsage M1-1-02执行筛选更新字段主键（特殊方法）  15659
      //ModelCode: filterUpdateFieldPrimaryKey
        ImplementScreenUpdateFieldFkRespDto filterUpdateFieldPrimaryKeyRes = null;
    if(listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)&& listChangeColumn.size()>0 ){
          ImplementScreenUpdateFieldFkReqDto filterUpdateFieldPrimaryKeyReq=new ImplementScreenUpdateFieldFkReqDto();
  if(listChangeColumn!= null&& !CollectionUtil.isEmpty(listChangeColumn)&&  listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)){
      filterUpdateFieldPrimaryKeyReq.setBaseChangeColumnList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.base.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:305859_1_15659
    }
  
    /*M1-1-02执行筛选更新字段主键（特殊方法）[4384]   */
    
      filterUpdateFieldPrimaryKeyRes = nbChangeColumn.implementScreenUpdateFieldFk(filterUpdateFieldPrimaryKeyReq);
      
      
      
           }
//virtualUsage M1-1-02执行拼接主表修订记录（特殊方法）  15670
      //ModelCode: concatenateMasterTableRevisionRecords
        ImplementSplicingMainTableRevisionRecordRespDto concatenateMasterTableRevisionRecordsRes = null;
    if(listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)&& listChangeColumn.size()>0 ){
          ImplementSplicingMainTableRevisionRecordReqDto concatenateMasterTableRevisionRecordsReq=new ImplementSplicingMainTableRevisionRecordReqDto();
  if(listChangeColumn!= null&& !CollectionUtil.isEmpty(listChangeColumn)&&  listChangeColumn !=null&& !CollectionUtil.isEmpty(listChangeColumn)){
      concatenateMasterTableRevisionRecordsReq.setBaseChangeColumnList(listChangeColumn.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrframework.base.service.dto.common.BaseChangeColumnDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:305894_1_15670
    }
  
    /*M1-1-02执行拼接主表修订记录（特殊方法）[4385]   */
    
      concatenateMasterTableRevisionRecordsRes = nbChangeColumn.implementSplicingMainTableRevisionRecord(concatenateMasterTableRevisionRecordsReq);
      
      
      
           }
if((filterUpdateFieldPrimaryKeyRes!= null&& filterUpdateFieldPrimaryKeyRes.getInductionRecordId() != null )) {
        //if(M1-1-02执行筛选更新字段主键（特殊方法）.就职记录ID 值不等于空 )  15660
        
boolean bOOLEAN ;
    List<InductionRecord> listInductionRecord=new ArrayList<>();
  if(concatenateMasterTableRevisionRecordsRes!= null&&  concatenateMasterTableRevisionRecordsRes.getOrgInductionRecordList() !=null&& !CollectionUtil.isEmpty(concatenateMasterTableRevisionRecordsRes.getOrgInductionRecordList())){
      listInductionRecord = concatenateMasterTableRevisionRecordsRes.getOrgInductionRecordList().stream().map(item -> BeanUtil.toBean(item, InductionRecord.class)).collect(Collectors.toList());//objList-to-objLists//sourceId:306133_1_15667
    }
  
    /*1-3-13批量修改就职记录[1647]   */
    
      bOOLEAN = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
      }
if((filterUpdateFieldPrimaryKeyRes!= null&& filterUpdateFieldPrimaryKeyRes.getDeptId() != null )) {
        //if(M1-1-02执行筛选更新字段主键（特殊方法）.部门ID 值不等于空 )  15664
        
boolean bOOLEAN_1 ;
    List<Dept> listDept=new ArrayList<>();
  if(concatenateMasterTableRevisionRecordsRes!= null&&  concatenateMasterTableRevisionRecordsRes.getDeptList() !=null&& !CollectionUtil.isEmpty(concatenateMasterTableRevisionRecordsRes.getDeptList())){
      listDept = //objList-to-objLists
        concatenateMasterTableRevisionRecordsRes.getDeptList().stream().map(item -> {
      Dept elm = new Dept();
      elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:94015_2_15668
elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:94016_2_15668
if(item!=null){
      elm.setDeptId(item.getDeptId());//SimpleFieldAssign//sourceId:94006_2_15668
elm.setRoleMemberId(item.getRoleMemberId());//SimpleFieldAssign//sourceId:94007_2_15668
//elm.setDirectorInductionId(item.getDirectorInductionId());//SimpleFieldAssign//sourceId:94008_2_15668
elm.setDeptNumber(item.getDeptNumber());//SimpleFieldAssign//sourceId:94009_2_15668
elm.setDeptName(item.getDeptName());//SimpleFieldAssign//sourceId:94010_2_15668
elm.setDeptEnName(item.getDeptEnName());//SimpleFieldAssign//sourceId:94011_2_15668
elm.setDeptShortName(item.getDeptShortName());//SimpleFieldAssign//sourceId:94012_2_15668
elm.setDeptDutyDesc(item.getDeptDutyDesc());//SimpleFieldAssign//sourceId:94013_2_15668
elm.setDeptTargetDesc(item.getDeptTargetDesc());//SimpleFieldAssign//sourceId:94014_2_15668
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:306135_1_15668
    }
  
    /*1-3-09批量改部门[4387]   */
    
      bOOLEAN_1 = mDeptService.batchUpdateDept(listDept)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
      }
BatchWriteBackBaseChangeColComRespDto retData = new BatchWriteBackBaseChangeColComRespDto();
  
  

  
  
return retData;
  }
    // @Resource
    // private DataSource dataSource;
    //
}
